widget/nsFilePickerProxy.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsFilePickerProxy.h"
   8 #include "nsComponentManagerUtils.h"
   9 #include "nsIFile.h"
  10 #include "nsSimpleEnumerator.h"
  11 #include "mozilla/dom/BlobImpl.h"
  12 #include "mozilla/dom/Directory.h"
  13 #include "mozilla/dom/File.h"
  14 #include "mozilla/dom/BrowserChild.h"
  15 #include "mozilla/dom/BrowsingContext.h"
  16 #include "mozilla/dom/IPCBlobUtils.h"
  17
  18 using namespace mozilla::dom;
  19
  20 NS_IMPL_ISUPPORTS(nsFilePickerProxy, nsIFilePicker)
  21
  22 nsFilePickerProxy::nsFilePickerProxy()
  23     : mSelectedType(0), mCapture(captureNone), mIPCActive(false) {}
  24
  25 nsFilePickerProxy::~nsFilePickerProxy() = default;
  26
  27 NS_IMETHODIMP
  28 nsFilePickerProxy::Init(BrowsingContext* aBrowsingContext,
  29                         const nsAString& aTitle, nsIFilePicker::Mode aMode) {
  30   BrowserChild* browserChild =
  31       BrowserChild::GetFrom(aBrowsingContext->GetDocShell());
  32   if (!browserChild) {
  33     return NS_ERROR_FAILURE;
  34   }
  35
  36   mBrowsingContext = aBrowsingContext;
  37   mMode = aMode;
  38
  39   browserChild->SendPFilePickerConstructor(this, aTitle, aMode,
  40                                            aBrowsingContext);
  41
  42   mIPCActive = true;
  43   return NS_OK;
  44 }
  45
  46 void nsFilePickerProxy::InitNative(nsIWidget* aParent,
  47                                    const nsAString& aTitle) {}
  48
  49 NS_IMETHODIMP
  50 nsFilePickerProxy::AppendFilter(const nsAString& aTitle,
  51                                 const nsAString& aFilter) {
  52   mFilterNames.AppendElement(aTitle);
  53   mFilters.AppendElement(aFilter);
  54   return NS_OK;
  55 }
  56
  57 NS_IMETHODIMP
  58 nsFilePickerProxy::GetCapture(nsIFilePicker::CaptureTarget* aCapture) {
  59   *aCapture = mCapture;
  60   return NS_OK;
  61 }
  62
  63 NS_IMETHODIMP
  64 nsFilePickerProxy::SetCapture(nsIFilePicker::CaptureTarget aCapture) {
  65   mCapture = aCapture;
  66   return NS_OK;
  67 }
  68
  69 NS_IMETHODIMP
  70 nsFilePickerProxy::GetDefaultString(nsAString& aDefaultString) {
  71   aDefaultString = mDefault;
  72   return NS_OK;
  73 }
  74
  75 NS_IMETHODIMP
  76 nsFilePickerProxy::SetDefaultString(const nsAString& aDefaultString) {
  77   mDefault = aDefaultString;
  78   return NS_OK;
  79 }
  80
  81 NS_IMETHODIMP
  82 nsFilePickerProxy::GetDefaultExtension(nsAString& aDefaultExtension) {
  83   aDefaultExtension = mDefaultExtension;
  84   return NS_OK;
  85 }
  86
  87 NS_IMETHODIMP
  88 nsFilePickerProxy::SetDefaultExtension(const nsAString& aDefaultExtension) {
  89   mDefaultExtension = aDefaultExtension;
  90   return NS_OK;
  91 }
  92
  93 NS_IMETHODIMP
  94 nsFilePickerProxy::GetFilterIndex(int32_t* aFilterIndex) {
  95   *aFilterIndex = mSelectedType;
  96   return NS_OK;
  97 }
  98
  99 NS_IMETHODIMP
 100 nsFilePickerProxy::SetFilterIndex(int32_t aFilterIndex) {
 101   mSelectedType = aFilterIndex;
 102   return NS_OK;
 103 }
 104
 105 NS_IMETHODIMP
 106 nsFilePickerProxy::GetFile(nsIFile** aFile) {
 107   MOZ_ASSERT(false, "GetFile is unimplemented; use GetDomFileOrDirectory");
 108   return NS_ERROR_FAILURE;
 109 }
 110
 111 NS_IMETHODIMP
 112 nsFilePickerProxy::GetFileURL(nsIURI** aFileURL) {
 113   MOZ_ASSERT(false, "GetFileURL is unimplemented; use GetDomFileOrDirectory");
 114   return NS_ERROR_FAILURE;
 115 }
 116
 117 NS_IMETHODIMP
 118 nsFilePickerProxy::GetFiles(nsISimpleEnumerator** aFiles) {
 119   MOZ_ASSERT(false,
 120              "GetFiles is unimplemented; use GetDomFileOrDirectoryEnumerator");
 121   return NS_ERROR_FAILURE;
 122 }
 123
 124 nsresult nsFilePickerProxy::Show(nsIFilePicker::ResultCode* aReturn) {
 125   MOZ_ASSERT(false, "Show is unimplemented; use Open");
 126   return NS_ERROR_NOT_IMPLEMENTED;
 127 }
 128
 129 NS_IMETHODIMP
 130 nsFilePickerProxy::Open(nsIFilePickerShownCallback* aCallback) {
 131   mCallback = aCallback;
 132
 133   nsString displayDirectory;
 134   if (mDisplayDirectory) {
 135     mDisplayDirectory->GetPath(displayDirectory);
 136   }
 137
 138   if (!mIPCActive) {
 139     return NS_ERROR_FAILURE;
 140   }
 141
 142   SendOpen(mSelectedType, mAddToRecentDocs, mDefault, mDefaultExtension,
 143            mFilters, mFilterNames, mRawFilters, displayDirectory,
 144            mDisplaySpecialDirectory, mOkButtonLabel, mCapture);
 145
 146   return NS_OK;
 147 }
 148
 149 NS_IMETHODIMP
 150 nsFilePickerProxy::Close() {
 151   SendClose();
 152
 153   return NS_OK;
 154 }
 155
 156 mozilla::ipc::IPCResult nsFilePickerProxy::Recv__delete__(
 157     const MaybeInputData& aData, const nsIFilePicker::ResultCode& aResult) {
 158   auto* inner = mBrowsingContext->GetDOMWindow()
 159                     ? mBrowsingContext->GetDOMWindow()->GetCurrentInnerWindow()
 160                     : nullptr;
 161
 162   if (NS_WARN_IF(!inner)) {
 163     return IPC_OK();
 164   }
 165
 166   if (aData.type() == MaybeInputData::TInputBlobs) {
 167     const nsTArray<IPCBlob>& blobs = aData.get_InputBlobs().blobs();
 168     for (uint32_t i = 0; i < blobs.Length(); ++i) {
 169       RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(blobs[i]);
 170       NS_ENSURE_TRUE(blobImpl, IPC_OK());
 171
 172       if (!blobImpl->IsFile()) {
 173         return IPC_OK();
 174       }
 175
 176       RefPtr<File> file = File::Create(inner->AsGlobal(), blobImpl);
 177       if (NS_WARN_IF(!file)) {
 178         return IPC_OK();
 179       }
 180
 181       OwningFileOrDirectory* element = mFilesOrDirectories.AppendElement();
 182       element->SetAsFile() = file;
 183     }
 184   } else if (aData.type() == MaybeInputData::TInputDirectory) {
 185     nsCOMPtr<nsIFile> file;
 186     const nsAString& path(aData.get_InputDirectory().directoryPath());
 187     nsresult rv = NS_NewLocalFile(path, true, getter_AddRefs(file));
 188     if (NS_WARN_IF(NS_FAILED(rv))) {
 189       return IPC_OK();
 190     }
 191
 192     RefPtr<Directory> directory = Directory::Create(inner->AsGlobal(), file);
 193     MOZ_ASSERT(directory);
 194
 195     OwningFileOrDirectory* element = mFilesOrDirectories.AppendElement();
 196     element->SetAsDirectory() = directory;
 197   }
 198
 199   if (mCallback) {
 200     mCallback->Done(aResult);
 201     mCallback = nullptr;
 202   }
 203
 204   return IPC_OK();
 205 }
 206
 207 NS_IMETHODIMP
 208 nsFilePickerProxy::GetDomFileOrDirectory(nsISupports** aValue) {
 209   *aValue = nullptr;
 210   if (mFilesOrDirectories.IsEmpty()) {
 211     return NS_OK;
 212   }
 213
 214   MOZ_ASSERT(mFilesOrDirectories.Length() == 1);
 215
 216   if (mFilesOrDirectories[0].IsFile()) {
 217     nsCOMPtr<nsISupports> blob = ToSupports(mFilesOrDirectories[0].GetAsFile());
 218     blob.forget(aValue);
 219     return NS_OK;
 220   }
 221
 222   MOZ_ASSERT(mFilesOrDirectories[0].IsDirectory());
 223   RefPtr<Directory> directory = mFilesOrDirectories[0].GetAsDirectory();
 224   directory.forget(aValue);
 225   return NS_OK;
 226 }
 227
 228 namespace {
 229
 230 class SimpleEnumerator final : public nsSimpleEnumerator {
 231  public:
 232   explicit SimpleEnumerator(
 233       const nsTArray<OwningFileOrDirectory>& aFilesOrDirectories)
 234       : mFilesOrDirectories(aFilesOrDirectories.Clone()), mIndex(0) {}
 235
 236   NS_IMETHOD
 237   HasMoreElements(bool* aRetvalue) override {
 238     MOZ_ASSERT(aRetvalue);
 239     *aRetvalue = mIndex < mFilesOrDirectories.Length();
 240     return NS_OK;
 241   }
 242
 243   NS_IMETHOD
 244   GetNext(nsISupports** aValue) override {
 245     NS_ENSURE_TRUE(mIndex < mFilesOrDirectories.Length(), NS_ERROR_FAILURE);
 246
 247     uint32_t index = mIndex++;
 248
 249     if (mFilesOrDirectories[index].IsFile()) {
 250       nsCOMPtr<nsISupports> blob =
 251           ToSupports(mFilesOrDirectories[index].GetAsFile());
 252       blob.forget(aValue);
 253       return NS_OK;
 254     }
 255
 256     MOZ_ASSERT(mFilesOrDirectories[index].IsDirectory());
 257     RefPtr<Directory> directory = mFilesOrDirectories[index].GetAsDirectory();
 258     directory.forget(aValue);
 259     return NS_OK;
 260   }
 261
 262  private:
 263   nsTArray<mozilla::dom::OwningFileOrDirectory> mFilesOrDirectories;
 264   uint32_t mIndex;
 265 };
 266
 267 }  // namespace
 268
 269 NS_IMETHODIMP
 270 nsFilePickerProxy::GetDomFileOrDirectoryEnumerator(
 271     nsISimpleEnumerator** aDomfiles) {
 272   RefPtr<SimpleEnumerator> enumerator =
 273       new SimpleEnumerator(mFilesOrDirectories);
 274   enumerator.forget(aDomfiles);
 275   return NS_OK;
 276 }
 277
 278 void nsFilePickerProxy::ActorDestroy(ActorDestroyReason aWhy) {
 279   mIPCActive = false;
 280
 281   if (mCallback) {
 282     mCallback->Done(nsIFilePicker::returnCancel);
 283     mCallback = nullptr;
 284   }
 285 }
 286
 287 nsresult nsFilePickerProxy::ResolveSpecialDirectory(
 288     const nsAString& aSpecialDirectory) {
 289   MOZ_ASSERT(XRE_IsContentProcess());
 290   // Resolving the special-directory name to a path in both the child and parent
 291   // processes is redundant -- and sandboxing may prevent us from doing so in
 292   // the child process, anyway. (See bugs 1357846 and 1838244.)
 293   //
 294   // Unfortunately we can't easily verify that `aSpecialDirectory` is usable or
 295   // even meaningful here, so we just accept anything.
 296   return NS_OK;
 297 }