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