Line data Source code
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 :
16 : #include "nsTransferable.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 "nsXPIDLString.h"
31 : #include "nsDirectoryServiceDefs.h"
32 : #include "nsDirectoryService.h"
33 : #include "nsCRT.h"
34 : #include "nsNetUtil.h"
35 : #include "nsIDOMNode.h"
36 : #include "nsIOutputStream.h"
37 : #include "nsIInputStream.h"
38 : #include "nsIWeakReferenceUtils.h"
39 : #include "nsIFile.h"
40 : #include "nsILoadContext.h"
41 : #include "mozilla/UniquePtr.h"
42 :
43 0 : NS_IMPL_ISUPPORTS(nsTransferable, nsITransferable)
44 :
45 0 : size_t GetDataForFlavor (const nsTArray<DataStruct>& aArray,
46 : const char* aDataFlavor)
47 : {
48 0 : for (size_t i = 0 ; i < aArray.Length () ; ++i) {
49 0 : if (aArray[i].GetFlavor().Equals (aDataFlavor))
50 0 : return i;
51 : }
52 :
53 0 : return aArray.NoIndex;
54 : }
55 :
56 : //-------------------------------------------------------------------------
57 0 : DataStruct::~DataStruct()
58 : {
59 0 : if (mCacheFileName) free(mCacheFileName);
60 0 : }
61 :
62 : //-------------------------------------------------------------------------
63 : void
64 0 : DataStruct::SetData ( nsISupports* aData, uint32_t aDataLen, bool aIsPrivateData )
65 : {
66 : // Now, check to see if we consider the data to be "too large"
67 : // as well as ensuring that private browsing mode is disabled
68 0 : if (aDataLen > kLargeDatasetSize && !aIsPrivateData) {
69 : // if so, cache it to disk instead of memory
70 0 : if ( NS_SUCCEEDED(WriteCache(aData, aDataLen)) )
71 0 : return;
72 : else
73 0 : NS_WARNING("Oh no, couldn't write data to the cache file");
74 : }
75 :
76 0 : mData = aData;
77 0 : mDataLen = aDataLen;
78 : }
79 :
80 :
81 : //-------------------------------------------------------------------------
82 : void
83 0 : DataStruct::GetData ( nsISupports** aData, uint32_t *aDataLen )
84 : {
85 : // check here to see if the data is cached on disk
86 0 : if ( !mData && mCacheFileName ) {
87 : // if so, read it in and pass it back
88 : // ReadCache creates memory and copies the data into it.
89 0 : if ( NS_SUCCEEDED(ReadCache(aData, aDataLen)) )
90 0 : return;
91 : else {
92 : // oh shit, something went horribly wrong here.
93 0 : NS_WARNING("Oh no, couldn't read data in from the cache file");
94 0 : *aData = nullptr;
95 0 : *aDataLen = 0;
96 0 : return;
97 : }
98 : }
99 :
100 0 : *aData = mData;
101 0 : if ( mData )
102 0 : NS_ADDREF(*aData);
103 0 : *aDataLen = mDataLen;
104 : }
105 :
106 :
107 : //-------------------------------------------------------------------------
108 : already_AddRefed<nsIFile>
109 0 : DataStruct::GetFileSpec(const char* aFileName)
110 : {
111 0 : nsCOMPtr<nsIFile> cacheFile;
112 0 : NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(cacheFile));
113 :
114 0 : if (!cacheFile)
115 0 : return nullptr;
116 :
117 : // if the param aFileName contains a name we should use that
118 : // because the file probably already exists
119 : // otherwise create a unique name
120 0 : if (!aFileName) {
121 0 : cacheFile->AppendNative(NS_LITERAL_CSTRING("clipboardcache"));
122 0 : nsresult rv = cacheFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
123 0 : if (NS_FAILED(rv))
124 0 : return nullptr;
125 : } else {
126 0 : cacheFile->AppendNative(nsDependentCString(aFileName));
127 : }
128 :
129 0 : return cacheFile.forget();
130 : }
131 :
132 :
133 : //-------------------------------------------------------------------------
134 : nsresult
135 0 : DataStruct::WriteCache(nsISupports* aData, uint32_t aDataLen)
136 : {
137 : // Get a new path and file to the temp directory
138 0 : nsCOMPtr<nsIFile> cacheFile = GetFileSpec(mCacheFileName);
139 0 : if (cacheFile) {
140 : // remember the file name
141 0 : if (!mCacheFileName) {
142 0 : nsXPIDLCString fName;
143 0 : cacheFile->GetNativeLeafName(fName);
144 0 : mCacheFileName = strdup(fName);
145 : }
146 :
147 : // write out the contents of the clipboard
148 : // to the file
149 : //uint32_t bytes;
150 0 : nsCOMPtr<nsIOutputStream> outStr;
151 :
152 0 : NS_NewLocalFileOutputStream(getter_AddRefs(outStr),
153 0 : cacheFile);
154 :
155 0 : if (!outStr) return NS_ERROR_FAILURE;
156 :
157 0 : void* buff = nullptr;
158 0 : nsPrimitiveHelpers::CreateDataFromPrimitive ( mFlavor.get(), aData, &buff, aDataLen );
159 0 : if ( buff ) {
160 : uint32_t ignored;
161 0 : outStr->Write(reinterpret_cast<char*>(buff), aDataLen, &ignored);
162 0 : free(buff);
163 0 : return NS_OK;
164 : }
165 : }
166 0 : return NS_ERROR_FAILURE;
167 : }
168 :
169 :
170 : //-------------------------------------------------------------------------
171 : nsresult
172 0 : DataStruct::ReadCache(nsISupports** aData, uint32_t* aDataLen)
173 : {
174 : // if we don't have a cache filename we are out of luck
175 0 : if (!mCacheFileName)
176 0 : return NS_ERROR_FAILURE;
177 :
178 : // get the path and file name
179 0 : nsCOMPtr<nsIFile> cacheFile = GetFileSpec(mCacheFileName);
180 : bool exists;
181 0 : if ( cacheFile && NS_SUCCEEDED(cacheFile->Exists(&exists)) && exists ) {
182 : // get the size of the file
183 : int64_t fileSize;
184 0 : int64_t max32 = 0xFFFFFFFF;
185 0 : cacheFile->GetFileSize(&fileSize);
186 0 : if (fileSize > max32)
187 0 : return NS_ERROR_OUT_OF_MEMORY;
188 :
189 0 : uint32_t size = uint32_t(fileSize);
190 : // create new memory for the large clipboard data
191 0 : auto data = mozilla::MakeUnique<char[]>(size);
192 0 : if ( !data )
193 0 : return NS_ERROR_OUT_OF_MEMORY;
194 :
195 : // now read it all in
196 0 : nsCOMPtr<nsIInputStream> inStr;
197 0 : NS_NewLocalFileInputStream( getter_AddRefs(inStr),
198 0 : cacheFile);
199 :
200 0 : if (!cacheFile) return NS_ERROR_FAILURE;
201 :
202 0 : nsresult rv = inStr->Read(data.get(), fileSize, aDataLen);
203 :
204 : // make sure we got all the data ok
205 0 : if (NS_SUCCEEDED(rv) && *aDataLen == size) {
206 0 : nsPrimitiveHelpers::CreatePrimitiveForData(mFlavor.get(), data.get(),
207 0 : fileSize, aData);
208 0 : return *aData ? NS_OK : NS_ERROR_FAILURE;
209 : }
210 :
211 : // zero the return params
212 0 : *aData = nullptr;
213 0 : *aDataLen = 0;
214 : }
215 :
216 0 : return NS_ERROR_FAILURE;
217 : }
218 :
219 :
220 : //-------------------------------------------------------------------------
221 : //
222 : // Transferable constructor
223 : //
224 : //-------------------------------------------------------------------------
225 0 : nsTransferable::nsTransferable()
226 : : mPrivateData(false)
227 : , mContentPolicyType(nsIContentPolicy::TYPE_OTHER)
228 : #ifdef DEBUG
229 0 : , mInitialized(false)
230 : #endif
231 : {
232 0 : }
233 :
234 : //-------------------------------------------------------------------------
235 : //
236 : // Transferable destructor
237 : //
238 : //-------------------------------------------------------------------------
239 0 : nsTransferable::~nsTransferable()
240 : {
241 0 : }
242 :
243 :
244 : NS_IMETHODIMP
245 0 : nsTransferable::Init(nsILoadContext* aContext)
246 : {
247 0 : MOZ_ASSERT(!mInitialized);
248 :
249 0 : if (aContext) {
250 0 : mPrivateData = aContext->UsePrivateBrowsing();
251 : }
252 : #ifdef DEBUG
253 0 : mInitialized = true;
254 : #endif
255 0 : return NS_OK;
256 : }
257 :
258 : //
259 : // GetTransferDataFlavors
260 : //
261 : // Returns a copy of the internal list of flavors. This does NOT take into
262 : // account any converter that may be registered. This list consists of
263 : // nsISupportsCString objects so that the flavor list can be accessed from JS.
264 : //
265 : already_AddRefed<nsIMutableArray>
266 0 : nsTransferable::GetTransferDataFlavors()
267 : {
268 0 : MOZ_ASSERT(mInitialized);
269 :
270 0 : nsCOMPtr<nsIMutableArray> array = nsArray::Create();
271 :
272 0 : for (size_t i = 0; i < mDataArray.Length(); ++i) {
273 0 : DataStruct& data = mDataArray.ElementAt(i);
274 0 : nsCOMPtr<nsISupportsCString> flavorWrapper = do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID);
275 0 : if ( flavorWrapper ) {
276 0 : flavorWrapper->SetData ( data.GetFlavor() );
277 0 : nsCOMPtr<nsISupports> genericWrapper ( do_QueryInterface(flavorWrapper) );
278 0 : array->AppendElement( genericWrapper, /*weak =*/ false );
279 : }
280 : }
281 :
282 0 : return array.forget();
283 : }
284 :
285 :
286 : //
287 : // GetTransferData
288 : //
289 : // Returns the data of the requested flavor, obtained from either having the data on hand or
290 : // using a converter to get it. The data is wrapped in a nsISupports primitive so that it is
291 : // accessible from JS.
292 : //
293 : NS_IMETHODIMP
294 0 : nsTransferable::GetTransferData(const char *aFlavor, nsISupports **aData, uint32_t *aDataLen)
295 : {
296 0 : MOZ_ASSERT(mInitialized);
297 :
298 0 : NS_ENSURE_ARG_POINTER(aFlavor && aData && aDataLen);
299 :
300 0 : nsresult rv = NS_OK;
301 0 : nsCOMPtr<nsISupports> savedData;
302 :
303 : // first look and see if the data is present in one of the intrinsic flavors
304 0 : for (size_t i = 0; i < mDataArray.Length(); ++i) {
305 0 : DataStruct& data = mDataArray.ElementAt(i);
306 0 : if ( data.GetFlavor().Equals(aFlavor) ) {
307 0 : nsCOMPtr<nsISupports> dataBytes;
308 : uint32_t len;
309 0 : data.GetData(getter_AddRefs(dataBytes), &len);
310 0 : if (len == kFlavorHasDataProvider && dataBytes) {
311 : // do we have a data provider?
312 0 : nsCOMPtr<nsIFlavorDataProvider> dataProvider = do_QueryInterface(dataBytes);
313 0 : if (dataProvider) {
314 0 : rv = dataProvider->GetFlavorData(this, aFlavor,
315 0 : getter_AddRefs(dataBytes), &len);
316 0 : if (NS_FAILED(rv))
317 0 : break; // the provider failed. fall into the converter code below.
318 : }
319 : }
320 0 : if (dataBytes && len > 0) { // XXXmats why is zero length not ok?
321 0 : *aDataLen = len;
322 0 : dataBytes.forget(aData);
323 0 : return NS_OK;
324 : }
325 0 : savedData = dataBytes; // return this if format converter fails
326 0 : break;
327 : }
328 : }
329 :
330 0 : bool found = false;
331 :
332 : // if not, try using a format converter to get the requested flavor
333 0 : if ( mFormatConv ) {
334 0 : for (size_t i = 0; i < mDataArray.Length(); ++i) {
335 0 : DataStruct& data = mDataArray.ElementAt(i);
336 0 : bool canConvert = false;
337 0 : mFormatConv->CanConvert(data.GetFlavor().get(), aFlavor, &canConvert);
338 0 : if ( canConvert ) {
339 0 : nsCOMPtr<nsISupports> dataBytes;
340 : uint32_t len;
341 0 : data.GetData(getter_AddRefs(dataBytes), &len);
342 0 : if (len == kFlavorHasDataProvider && dataBytes) {
343 : // do we have a data provider?
344 0 : nsCOMPtr<nsIFlavorDataProvider> dataProvider = do_QueryInterface(dataBytes);
345 0 : if (dataProvider) {
346 0 : rv = dataProvider->GetFlavorData(this, aFlavor,
347 0 : getter_AddRefs(dataBytes), &len);
348 0 : if (NS_FAILED(rv))
349 0 : break; // give up
350 : }
351 : }
352 0 : mFormatConv->Convert(data.GetFlavor().get(), dataBytes, len, aFlavor, aData, aDataLen);
353 0 : found = true;
354 0 : break;
355 : }
356 : }
357 : }
358 :
359 : // for backward compatibility
360 0 : if (!found) {
361 0 : savedData.forget(aData);
362 0 : *aDataLen = 0;
363 : }
364 :
365 0 : return found ? NS_OK : NS_ERROR_FAILURE;
366 : }
367 :
368 :
369 : //
370 : // GetAnyTransferData
371 : //
372 : // Returns the data of the first flavor found. Caller is responsible for deleting the
373 : // flavor string.
374 : //
375 : NS_IMETHODIMP
376 0 : nsTransferable::GetAnyTransferData(nsACString& aFlavor, nsISupports **aData,
377 : uint32_t *aDataLen)
378 : {
379 0 : MOZ_ASSERT(mInitialized);
380 :
381 0 : NS_ENSURE_ARG_POINTER(aData && aDataLen);
382 :
383 0 : for (size_t i = 0; i < mDataArray.Length(); ++i) {
384 0 : DataStruct& data = mDataArray.ElementAt(i);
385 0 : if (data.IsDataAvailable()) {
386 0 : aFlavor.Assign(data.GetFlavor());
387 0 : data.GetData(aData, aDataLen);
388 0 : return NS_OK;
389 : }
390 : }
391 :
392 0 : return NS_ERROR_FAILURE;
393 : }
394 :
395 :
396 : //
397 : // SetTransferData
398 : //
399 : //
400 : //
401 : NS_IMETHODIMP
402 0 : nsTransferable::SetTransferData(const char *aFlavor, nsISupports *aData, uint32_t aDataLen)
403 : {
404 0 : MOZ_ASSERT(mInitialized);
405 :
406 0 : NS_ENSURE_ARG(aFlavor);
407 :
408 : // first check our intrinsic flavors to see if one has been registered.
409 0 : for (size_t i = 0; i < mDataArray.Length(); ++i) {
410 0 : DataStruct& data = mDataArray.ElementAt(i);
411 0 : if ( data.GetFlavor().Equals(aFlavor) ) {
412 0 : data.SetData ( aData, aDataLen, mPrivateData );
413 0 : return NS_OK;
414 : }
415 : }
416 :
417 : // if not, try using a format converter to find a flavor to put the data in
418 0 : if ( mFormatConv ) {
419 0 : for (size_t i = 0; i < mDataArray.Length(); ++i) {
420 0 : DataStruct& data = mDataArray.ElementAt(i);
421 0 : bool canConvert = false;
422 0 : mFormatConv->CanConvert(aFlavor, data.GetFlavor().get(), &canConvert);
423 :
424 0 : if ( canConvert ) {
425 0 : nsCOMPtr<nsISupports> ConvertedData;
426 : uint32_t ConvertedLen;
427 0 : mFormatConv->Convert(aFlavor, aData, aDataLen, data.GetFlavor().get(), getter_AddRefs(ConvertedData), &ConvertedLen);
428 0 : data.SetData(ConvertedData, ConvertedLen, mPrivateData);
429 0 : return NS_OK;
430 : }
431 : }
432 : }
433 :
434 : // Can't set data neither directly nor through converter. Just add this flavor and try again
435 0 : nsresult result = NS_ERROR_FAILURE;
436 0 : if ( NS_SUCCEEDED(AddDataFlavor(aFlavor)) )
437 0 : result = SetTransferData (aFlavor, aData, aDataLen);
438 :
439 0 : return result;
440 : }
441 :
442 :
443 : //
444 : // AddDataFlavor
445 : //
446 : // Adds a data flavor to our list with no data. Error if it already exists.
447 : //
448 : NS_IMETHODIMP
449 0 : nsTransferable::AddDataFlavor(const char *aDataFlavor)
450 : {
451 0 : MOZ_ASSERT(mInitialized);
452 :
453 0 : if (GetDataForFlavor (mDataArray, aDataFlavor) != mDataArray.NoIndex)
454 0 : return NS_ERROR_FAILURE;
455 :
456 : // Create a new "slot" for the data
457 0 : mDataArray.AppendElement(DataStruct ( aDataFlavor ));
458 :
459 0 : return NS_OK;
460 : }
461 :
462 :
463 : //
464 : // RemoveDataFlavor
465 : //
466 : // Removes a data flavor (and causes the data to be destroyed). Error if
467 : // the requested flavor is not present.
468 : //
469 : NS_IMETHODIMP
470 0 : nsTransferable::RemoveDataFlavor(const char *aDataFlavor)
471 : {
472 0 : MOZ_ASSERT(mInitialized);
473 :
474 0 : size_t idx = GetDataForFlavor(mDataArray, aDataFlavor);
475 0 : if (idx != mDataArray.NoIndex) {
476 0 : mDataArray.RemoveElementAt (idx);
477 0 : return NS_OK;
478 : }
479 0 : return NS_ERROR_FAILURE;
480 : }
481 :
482 :
483 : /**
484 : *
485 : *
486 : */
487 : NS_IMETHODIMP
488 0 : nsTransferable::IsLargeDataSet(bool *_retval)
489 : {
490 0 : MOZ_ASSERT(mInitialized);
491 :
492 0 : NS_ENSURE_ARG_POINTER(_retval);
493 0 : *_retval = false;
494 0 : return NS_OK;
495 : }
496 :
497 :
498 : /**
499 : *
500 : *
501 : */
502 0 : NS_IMETHODIMP nsTransferable::SetConverter(nsIFormatConverter * aConverter)
503 : {
504 0 : MOZ_ASSERT(mInitialized);
505 :
506 0 : mFormatConv = aConverter;
507 0 : return NS_OK;
508 : }
509 :
510 :
511 : /**
512 : *
513 : *
514 : */
515 0 : NS_IMETHODIMP nsTransferable::GetConverter(nsIFormatConverter * *aConverter)
516 : {
517 0 : MOZ_ASSERT(mInitialized);
518 :
519 0 : NS_ENSURE_ARG_POINTER(aConverter);
520 0 : *aConverter = mFormatConv;
521 0 : NS_IF_ADDREF(*aConverter);
522 0 : return NS_OK;
523 : }
524 :
525 :
526 : //
527 : // FlavorsTransferableCanImport
528 : //
529 : // Computes a list of flavors that the transferable can accept into it, either through
530 : // intrinsic knowledge or input data converters.
531 : //
532 : NS_IMETHODIMP
533 0 : nsTransferable::FlavorsTransferableCanImport(nsIArray **_retval)
534 : {
535 0 : MOZ_ASSERT(mInitialized);
536 :
537 0 : NS_ENSURE_ARG_POINTER(_retval);
538 :
539 : // Get the flavor list, and on to the end of it, append the list of flavors we
540 : // can also get to through a converter. This is so that we can just walk the list
541 : // in one go, looking for the desired flavor.
542 0 : nsCOMPtr<nsIMutableArray> array = GetTransferDataFlavors();
543 0 : nsCOMPtr<nsIFormatConverter> converter;
544 0 : GetConverter(getter_AddRefs(converter));
545 0 : if ( converter ) {
546 0 : nsCOMPtr<nsIArray> convertedList;
547 0 : converter->GetInputDataFlavors(getter_AddRefs(convertedList));
548 :
549 0 : if ( convertedList ) {
550 : uint32_t importListLen;
551 0 : convertedList->GetLength(&importListLen);
552 :
553 0 : for (uint32_t i = 0; i < importListLen; ++i ) {
554 : nsCOMPtr<nsISupportsCString> flavorWrapper =
555 0 : do_QueryElementAt(convertedList, i);
556 0 : nsAutoCString flavorStr;
557 0 : flavorWrapper->GetData( flavorStr );
558 :
559 0 : if (GetDataForFlavor (mDataArray, flavorStr.get())
560 : == mDataArray.NoIndex) // Don't append if already in intrinsic list
561 0 : array->AppendElement (flavorWrapper, /*weak =*/ false);
562 : } // foreach flavor that can be converted to
563 : }
564 : } // if a converter exists
565 :
566 0 : array.forget(_retval);
567 0 : return NS_OK;
568 : } // FlavorsTransferableCanImport
569 :
570 :
571 : //
572 : // FlavorsTransferableCanExport
573 : //
574 : // Computes a list of flavors that the transferable can export, either through
575 : // intrinsic knowledge or output data converters.
576 : //
577 : NS_IMETHODIMP
578 0 : nsTransferable::FlavorsTransferableCanExport(nsIArray **_retval)
579 : {
580 0 : MOZ_ASSERT(mInitialized);
581 :
582 0 : NS_ENSURE_ARG_POINTER(_retval);
583 :
584 : // Get the flavor list, and on to the end of it, append the list of flavors we
585 : // can also get to through a converter. This is so that we can just walk the list
586 : // in one go, looking for the desired flavor.
587 0 : nsCOMPtr<nsIMutableArray> array = GetTransferDataFlavors();
588 0 : nsCOMPtr<nsIFormatConverter> converter;
589 0 : GetConverter(getter_AddRefs(converter));
590 0 : if ( converter ) {
591 0 : nsCOMPtr<nsIArray> convertedList;
592 0 : converter->GetOutputDataFlavors(getter_AddRefs(convertedList));
593 :
594 0 : if ( convertedList ) {
595 : uint32_t importListLen;
596 0 : convertedList->GetLength(&importListLen);
597 :
598 0 : for ( uint32_t i=0; i < importListLen; ++i ) {
599 : nsCOMPtr<nsISupportsCString> flavorWrapper =
600 0 : do_QueryElementAt(convertedList, i);
601 0 : nsAutoCString flavorStr;
602 0 : flavorWrapper->GetData( flavorStr );
603 :
604 0 : if (GetDataForFlavor (mDataArray, flavorStr.get())
605 : == mDataArray.NoIndex) // Don't append if already in intrinsic list
606 0 : array->AppendElement (flavorWrapper, /*weak =*/ false);
607 : } // foreach flavor that can be converted to
608 : }
609 : } // if a converter exists
610 :
611 0 : array.forget(_retval);
612 0 : return NS_OK;
613 : } // FlavorsTransferableCanExport
614 :
615 : NS_IMETHODIMP
616 0 : nsTransferable::GetIsPrivateData(bool *aIsPrivateData)
617 : {
618 0 : MOZ_ASSERT(mInitialized);
619 :
620 0 : NS_ENSURE_ARG_POINTER(aIsPrivateData);
621 :
622 0 : *aIsPrivateData = mPrivateData;
623 :
624 0 : return NS_OK;
625 : }
626 :
627 : NS_IMETHODIMP
628 0 : nsTransferable::SetIsPrivateData(bool aIsPrivateData)
629 : {
630 0 : MOZ_ASSERT(mInitialized);
631 :
632 0 : mPrivateData = aIsPrivateData;
633 :
634 0 : return NS_OK;
635 : }
636 :
637 : NS_IMETHODIMP
638 0 : nsTransferable::GetRequestingPrincipal(nsIPrincipal** outRequestingPrincipal)
639 : {
640 0 : NS_IF_ADDREF(*outRequestingPrincipal = mRequestingPrincipal);
641 0 : return NS_OK;
642 : }
643 :
644 : NS_IMETHODIMP
645 0 : nsTransferable::SetRequestingPrincipal(nsIPrincipal* aRequestingPrincipal)
646 : {
647 0 : mRequestingPrincipal = aRequestingPrincipal;
648 0 : return NS_OK;
649 : }
650 :
651 : NS_IMETHODIMP
652 0 : nsTransferable::GetContentPolicyType(nsContentPolicyType* outContentPolicyType)
653 : {
654 0 : NS_ENSURE_ARG_POINTER(outContentPolicyType);
655 0 : *outContentPolicyType = mContentPolicyType;
656 0 : return NS_OK;
657 : }
658 :
659 : NS_IMETHODIMP
660 0 : nsTransferable::SetContentPolicyType(nsContentPolicyType aContentPolicyType)
661 : {
662 0 : mContentPolicyType = aContentPolicyType;
663 0 : return NS_OK;
664 : }
|
