widget/nsTransferable.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /*
   7 Notes to self:
   8
   9 - at some point, strings will be accessible from JS, so we won't have to wrap
  10    flavors in an nsISupportsCString. Until then, we're kinda stuck with
  11    this crappy API of nsIArrays.
  12
  13 */
  14
  15 #include "nsTransferable.h"
  16 #include "nsAnonymousTemporaryFile.h"
  17 #include "nsArray.h"
  18 #include "nsArrayUtils.h"
  19 #include "nsString.h"
  20 #include "nsReadableUtils.h"
  21 #include "nsTArray.h"
  22 #include "nsIFormatConverter.h"
  23 #include "nsIContentPolicy.h"
  24 #include "nsIComponentManager.h"
  25 #include "nsCOMPtr.h"
  26 #include "nsXPCOM.h"
  27 #include "nsISupportsPrimitives.h"
  28 #include "nsMemory.h"
  29 #include "nsPrimitiveHelpers.h"
  30 #include "nsDirectoryServiceDefs.h"
  31 #include "nsDirectoryService.h"
  32 #include "nsCRT.h"
  33 #include "nsNetUtil.h"
  34 #include "nsIOutputStream.h"
  35 #include "nsIInputStream.h"
  36 #include "nsILoadContext.h"
  37 #include "nsXULAppAPI.h"
  38 #include "mozilla/UniquePtr.h"
  39
  40 using namespace mozilla;
  41
  42 NS_IMPL_ISUPPORTS(nsTransferable, nsITransferable)
  43
  44 DataStruct::DataStruct(DataStruct&& aRHS)
  45     : mData(aRHS.mData.forget()),
  46       mCacheFD(aRHS.mCacheFD),
  47       mFlavor(aRHS.mFlavor) {
  48   aRHS.mCacheFD = nullptr;
  49 }
  50
  51 //-------------------------------------------------------------------------
  52 DataStruct::~DataStruct() {
  53   if (mCacheFD) {
  54     PR_Close(mCacheFD);
  55   }
  56 }
  57
  58 //-------------------------------------------------------------------------
  59
  60 void DataStruct::SetData(nsISupports* aData, bool aIsPrivateData) {
  61   // Now, check to see if we consider the data to be "too large"
  62   // as well as ensuring that private browsing mode is disabled.
  63   // File IO is not allowed in content processes.
  64   if (!aIsPrivateData && XRE_IsParentProcess()) {
  65     void* data = nullptr;
  66     uint32_t dataLen = 0;
  67     nsPrimitiveHelpers::CreateDataFromPrimitive(mFlavor, aData, &data,
  68                                                 &dataLen);
  69
  70     if (dataLen > kLargeDatasetSize) {
  71       // Too large, cache it to disk instead of memory.
  72       if (NS_SUCCEEDED(WriteCache(data, dataLen))) {
  73         free(data);
  74         // Clear previously set small data.
  75         mData = nullptr;
  76         return;
  77       }
  78
  79       NS_WARNING("Oh no, couldn't write data to the cache file");
  80     }
  81
  82     free(data);
  83   }
  84
  85   if (mCacheFD) {
  86     // Clear previously set big data.
  87     PR_Close(mCacheFD);
  88     mCacheFD = nullptr;
  89   }
  90
  91   mData = aData;
  92 }
  93
  94 //-------------------------------------------------------------------------
  95 void DataStruct::GetData(nsISupports** aData) {
  96   // check here to see if the data is cached on disk
  97   if (mCacheFD) {
  98     // if so, read it in and pass it back
  99     // ReadCache creates memory and copies the data into it.
 100     if (NS_SUCCEEDED(ReadCache(aData))) {
 101       return;
 102     }
 103
 104     // oh shit, something went horribly wrong here.
 105     NS_WARNING("Oh no, couldn't read data in from the cache file");
 106     *aData = nullptr;
 107     PR_Close(mCacheFD);
 108     mCacheFD = nullptr;
 109     return;
 110   }
 111
 112   nsCOMPtr<nsISupports> data = mData;
 113   data.forget(aData);
 114 }
 115
 116 //-------------------------------------------------------------------------
 117 nsresult DataStruct::WriteCache(void* aData, uint32_t aDataLen) {
 118   MOZ_ASSERT(aData && aDataLen);
 119   MOZ_ASSERT(aDataLen <= uint32_t(std::numeric_limits<int32_t>::max()),
 120              "too large size for PR_Write");
 121
 122   nsresult rv;
 123   if (!mCacheFD) {
 124     rv = NS_OpenAnonymousTemporaryFile(&mCacheFD);
 125     if (NS_FAILED(rv)) {
 126       return NS_ERROR_FAILURE;
 127     }
 128   } else if (PR_Seek64(mCacheFD, 0, PR_SEEK_SET) == -1) {
 129     return NS_ERROR_FAILURE;
 130   }
 131
 132   // Write out the contents of the clipboard to the file.
 133   int32_t written = PR_Write(mCacheFD, aData, aDataLen);
 134   if (written == int32_t(aDataLen)) {
 135     return NS_OK;
 136   }
 137
 138   PR_Close(mCacheFD);
 139   mCacheFD = nullptr;
 140   return NS_ERROR_FAILURE;
 141 }
 142
 143 //-------------------------------------------------------------------------
 144 nsresult DataStruct::ReadCache(nsISupports** aData) {
 145   if (!mCacheFD) {
 146     return NS_ERROR_FAILURE;
 147   }
 148
 149   PRFileInfo fileInfo;
 150   if (PR_GetOpenFileInfo(mCacheFD, &fileInfo) != PR_SUCCESS) {
 151     return NS_ERROR_FAILURE;
 152   }
 153   if (PR_Seek64(mCacheFD, 0, PR_SEEK_SET) == -1) {
 154     return NS_ERROR_FAILURE;
 155   }
 156   uint32_t fileSize = fileInfo.size;
 157
 158   auto data = MakeUnique<char[]>(fileSize);
 159   if (!data) {
 160     return NS_ERROR_OUT_OF_MEMORY;
 161   }
 162
 163   uint32_t actual = PR_Read(mCacheFD, data.get(), fileSize);
 164   if (actual != fileSize) {
 165     return NS_ERROR_FAILURE;
 166   }
 167
 168   nsPrimitiveHelpers::CreatePrimitiveForData(mFlavor, data.get(), fileSize,
 169                                              aData);
 170   return NS_OK;
 171 }
 172
 173 //-------------------------------------------------------------------------
 174 //
 175 // Transferable constructor
 176 //
 177 //-------------------------------------------------------------------------
 178 nsTransferable::nsTransferable()
 179     : mPrivateData(false),
 180       mContentPolicyType(nsIContentPolicy::TYPE_OTHER)
 181 #ifdef DEBUG
 182       ,
 183       mInitialized(false)
 184 #endif
 185 {
 186 }
 187
 188 //-------------------------------------------------------------------------
 189 //
 190 // Transferable destructor
 191 //
 192 //-------------------------------------------------------------------------
 193 nsTransferable::~nsTransferable() {}
 194
 195 NS_IMETHODIMP
 196 nsTransferable::Init(nsILoadContext* aContext) {
 197   MOZ_ASSERT(!mInitialized);
 198
 199   if (aContext) {
 200     mPrivateData = aContext->UsePrivateBrowsing();
 201   }
 202 #ifdef DEBUG
 203   mInitialized = true;
 204 #endif
 205   return NS_OK;
 206 }
 207
 208 //
 209 // GetTransferDataFlavors
 210 //
 211 // Returns a copy of the internal list of flavors. This does NOT take into
 212 // account any converter that may be registered.
 213 //
 214 void nsTransferable::GetTransferDataFlavors(nsTArray<nsCString>& aFlavors) {
 215   MOZ_ASSERT(mInitialized);
 216
 217   for (size_t i = 0; i < mDataArray.Length(); ++i) {
 218     DataStruct& data = mDataArray.ElementAt(i);
 219     aFlavors.AppendElement(data.GetFlavor());
 220   }
 221 }
 222
 223 Maybe<size_t> nsTransferable::FindDataFlavor(const char* aFlavor) {
 224   nsDependentCString flavor(aFlavor);
 225
 226   for (size_t i = 0; i < mDataArray.Length(); ++i) {
 227     if (mDataArray[i].GetFlavor().Equals(flavor)) {
 228       return Some(i);
 229     }
 230   }
 231
 232   return Nothing();
 233 }
 234
 235 //
 236 // GetTransferData
 237 //
 238 // Returns the data of the requested flavor, obtained from either having the
 239 // data on hand or using a converter to get it. The data is wrapped in a
 240 // nsISupports primitive so that it is accessible from JS.
 241 //
 242 NS_IMETHODIMP
 243 nsTransferable::GetTransferData(const char* aFlavor, nsISupports** aData) {
 244   MOZ_ASSERT(mInitialized);
 245
 246   *aData = nullptr;
 247
 248   nsresult rv = NS_OK;
 249
 250   // First look and see if the data is present in one of the intrinsic flavors.
 251   if (Maybe<size_t> index = FindDataFlavor(aFlavor)) {
 252     nsCOMPtr<nsISupports> dataBytes;
 253     mDataArray[index.value()].GetData(getter_AddRefs(dataBytes));
 254
 255     // Do we have a (lazy) data provider?
 256     if (nsCOMPtr<nsIFlavorDataProvider> dataProvider =
 257             do_QueryInterface(dataBytes)) {
 258       rv =
 259           dataProvider->GetFlavorData(this, aFlavor, getter_AddRefs(dataBytes));
 260       if (NS_FAILED(rv)) {
 261         dataBytes = nullptr;
 262         // The provider failed, fall into the converter code below.
 263       }
 264     }
 265
 266     if (dataBytes) {
 267       dataBytes.forget(aData);
 268       return NS_OK;
 269     }
 270
 271     // Empty data
 272   }
 273
 274   // If not, try using a format converter to get the requested flavor.
 275   if (mFormatConv) {
 276     for (size_t i = 0; i < mDataArray.Length(); ++i) {
 277       DataStruct& data = mDataArray.ElementAt(i);
 278       bool canConvert = false;
 279       mFormatConv->CanConvert(data.GetFlavor().get(), aFlavor, &canConvert);
 280       if (canConvert) {
 281         nsCOMPtr<nsISupports> dataBytes;
 282         data.GetData(getter_AddRefs(dataBytes));
 283
 284         // Do we have a (lazy) data provider?
 285         if (nsCOMPtr<nsIFlavorDataProvider> dataProvider =
 286                 do_QueryInterface(dataBytes)) {
 287           rv = dataProvider->GetFlavorData(this, aFlavor,
 288                                            getter_AddRefs(dataBytes));
 289           if (NS_FAILED(rv)) {
 290             // Give up.
 291             return rv;
 292           }
 293         }
 294
 295         return mFormatConv->Convert(data.GetFlavor().get(), dataBytes, aFlavor,
 296                                     aData);
 297       }
 298     }
 299   }
 300
 301   return NS_ERROR_FAILURE;
 302 }
 303
 304 //
 305 // GetAnyTransferData
 306 //
 307 // Returns the data of the first flavor found. Caller is responsible for
 308 // deleting the flavor string.
 309 //
 310 NS_IMETHODIMP
 311 nsTransferable::GetAnyTransferData(nsACString& aFlavor, nsISupports** aData) {
 312   MOZ_ASSERT(mInitialized);
 313
 314   for (size_t i = 0; i < mDataArray.Length(); ++i) {
 315     DataStruct& data = mDataArray.ElementAt(i);
 316     if (data.IsDataAvailable()) {
 317       aFlavor.Assign(data.GetFlavor());
 318       data.GetData(aData);
 319       return NS_OK;
 320     }
 321   }
 322
 323   return NS_ERROR_FAILURE;
 324 }
 325
 326 //
 327 // SetTransferData
 328 //
 329 //
 330 //
 331 NS_IMETHODIMP
 332 nsTransferable::SetTransferData(const char* aFlavor, nsISupports* aData) {
 333   MOZ_ASSERT(mInitialized);
 334
 335   // first check our intrinsic flavors to see if one has been registered.
 336   if (Maybe<size_t> index = FindDataFlavor(aFlavor)) {
 337     DataStruct& data = mDataArray.ElementAt(index.value());
 338     data.SetData(aData, mPrivateData);
 339     return NS_OK;
 340   }
 341
 342   // if not, try using a format converter to find a flavor to put the data in
 343   if (mFormatConv) {
 344     for (size_t i = 0; i < mDataArray.Length(); ++i) {
 345       DataStruct& data = mDataArray.ElementAt(i);
 346       bool canConvert = false;
 347       mFormatConv->CanConvert(aFlavor, data.GetFlavor().get(), &canConvert);
 348
 349       if (canConvert) {
 350         nsCOMPtr<nsISupports> ConvertedData;
 351         mFormatConv->Convert(aFlavor, aData, data.GetFlavor().get(),
 352                              getter_AddRefs(ConvertedData));
 353         data.SetData(ConvertedData, mPrivateData);
 354         return NS_OK;
 355       }
 356     }
 357   }
 358
 359   // Can't set data neither directly nor through converter. Just add this flavor
 360   // and try again
 361   if (NS_SUCCEEDED(AddDataFlavor(aFlavor))) {
 362     return SetTransferData(aFlavor, aData);
 363   }
 364
 365   return NS_ERROR_FAILURE;
 366 }
 367
 368 //
 369 // AddDataFlavor
 370 //
 371 // Adds a data flavor to our list with no data. Error if it already exists.
 372 //
 373 NS_IMETHODIMP
 374 nsTransferable::AddDataFlavor(const char* aDataFlavor) {
 375   MOZ_ASSERT(mInitialized);
 376
 377   if (FindDataFlavor(aDataFlavor).isSome()) {
 378     return NS_ERROR_FAILURE;
 379   }
 380
 381   // Create a new "slot" for the data
 382   mDataArray.AppendElement(DataStruct(aDataFlavor));
 383   return NS_OK;
 384 }
 385
 386 //
 387 // RemoveDataFlavor
 388 //
 389 // Removes a data flavor (and causes the data to be destroyed). Error if
 390 // the requested flavor is not present.
 391 //
 392 NS_IMETHODIMP
 393 nsTransferable::RemoveDataFlavor(const char* aDataFlavor) {
 394   MOZ_ASSERT(mInitialized);
 395
 396   if (Maybe<size_t> index = FindDataFlavor(aDataFlavor)) {
 397     mDataArray.RemoveElementAt(index.value());
 398     return NS_OK;
 399   }
 400
 401   return NS_ERROR_FAILURE;
 402 }
 403
 404 NS_IMETHODIMP
 405 nsTransferable::SetConverter(nsIFormatConverter* aConverter) {
 406   MOZ_ASSERT(mInitialized);
 407
 408   mFormatConv = aConverter;
 409   return NS_OK;
 410 }
 411
 412 NS_IMETHODIMP
 413 nsTransferable::GetConverter(nsIFormatConverter** aConverter) {
 414   MOZ_ASSERT(mInitialized);
 415
 416   nsCOMPtr<nsIFormatConverter> converter = mFormatConv;
 417   converter.forget(aConverter);
 418   return NS_OK;
 419 }
 420
 421 //
 422 // FlavorsTransferableCanImport
 423 //
 424 // Computes a list of flavors that the transferable can accept into it, either
 425 // through intrinsic knowledge or input data converters.
 426 //
 427 NS_IMETHODIMP
 428 nsTransferable::FlavorsTransferableCanImport(nsTArray<nsCString>& aFlavors) {
 429   MOZ_ASSERT(mInitialized);
 430
 431   // Get the flavor list, and on to the end of it, append the list of flavors we
 432   // can also get to through a converter. This is so that we can just walk the
 433   // list in one go, looking for the desired flavor.
 434   GetTransferDataFlavors(aFlavors);
 435
 436   if (mFormatConv) {
 437     nsTArray<nsCString> convertedList;
 438     mFormatConv->GetInputDataFlavors(convertedList);
 439
 440     for (uint32_t i = 0; i < convertedList.Length(); ++i) {
 441       nsCString& flavorStr = convertedList[i];
 442
 443       // Don't append if already in intrinsic list
 444       if (!aFlavors.Contains(flavorStr)) {
 445         aFlavors.AppendElement(flavorStr);
 446       }
 447     }
 448   }
 449
 450   return NS_OK;
 451 }
 452
 453 //
 454 // FlavorsTransferableCanExport
 455 //
 456 // Computes a list of flavors that the transferable can export, either through
 457 // intrinsic knowledge or output data converters.
 458 //
 459 NS_IMETHODIMP
 460 nsTransferable::FlavorsTransferableCanExport(nsTArray<nsCString>& aFlavors) {
 461   MOZ_ASSERT(mInitialized);
 462
 463   // Get the flavor list, and on to the end of it, append the list of flavors we
 464   // can also get to through a converter. This is so that we can just walk the
 465   // list in one go, looking for the desired flavor.
 466   GetTransferDataFlavors(aFlavors);
 467
 468   if (mFormatConv) {
 469     nsTArray<nsCString> convertedList;
 470     mFormatConv->GetOutputDataFlavors(convertedList);
 471
 472     for (uint32_t i = 0; i < convertedList.Length(); ++i) {
 473       nsCString& flavorStr = convertedList[i];
 474
 475       // Don't append if already in intrinsic list
 476       if (!aFlavors.Contains(flavorStr)) {
 477         aFlavors.AppendElement(flavorStr);
 478       }
 479     }
 480   }
 481
 482   return NS_OK;
 483 }
 484
 485 bool nsTransferable::GetIsPrivateData() {
 486   MOZ_ASSERT(mInitialized);
 487
 488   return mPrivateData;
 489 }
 490
 491 void nsTransferable::SetIsPrivateData(bool aIsPrivateData) {
 492   MOZ_ASSERT(mInitialized);
 493
 494   mPrivateData = aIsPrivateData;
 495 }
 496
 497 nsIPrincipal* nsTransferable::GetRequestingPrincipal() {
 498   MOZ_ASSERT(mInitialized);
 499
 500   return mRequestingPrincipal;
 501 }
 502
 503 void nsTransferable::SetRequestingPrincipal(
 504     nsIPrincipal* aRequestingPrincipal) {
 505   MOZ_ASSERT(mInitialized);
 506
 507   mRequestingPrincipal = aRequestingPrincipal;
 508 }
 509
 510 nsContentPolicyType nsTransferable::GetContentPolicyType() {
 511   MOZ_ASSERT(mInitialized);
 512
 513   return mContentPolicyType;
 514 }
 515
 516 void nsTransferable::SetContentPolicyType(
 517     nsContentPolicyType aContentPolicyType) {
 518   MOZ_ASSERT(mInitialized);
 519
 520   mContentPolicyType = aContentPolicyType;
 521 }