The Tor Browser: dom/events/ClipboardEvent.cpp@97036ab72558

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     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/. */

     6 #include "mozilla/dom/ClipboardEvent.h"

     7 #include "mozilla/ContentEvents.h"

     8 #include "mozilla/dom/DataTransfer.h"

     9 #include "nsIClipboard.h"

    11 namespace mozilla {

    12 namespace dom {

    14 ClipboardEvent::ClipboardEvent(EventTarget* aOwner,

    15                                nsPresContext* aPresContext,

    16                                InternalClipboardEvent* aEvent)

    17   : Event(aOwner, aPresContext,

    18           aEvent ? aEvent : new InternalClipboardEvent(false, 0))

    19 {

    20   if (aEvent) {

    21     mEventIsInternal = false;

    22   } else {

    23     mEventIsInternal = true;

    24     mEvent->time = PR_Now();

    25   }

    26 }

    28 NS_INTERFACE_MAP_BEGIN(ClipboardEvent)

    29   NS_INTERFACE_MAP_ENTRY(nsIDOMClipboardEvent)

    30 NS_INTERFACE_MAP_END_INHERITING(Event)

    32 NS_IMPL_ADDREF_INHERITED(ClipboardEvent, Event)

    33 NS_IMPL_RELEASE_INHERITED(ClipboardEvent, Event)

    35 nsresult

    36 ClipboardEvent::InitClipboardEvent(const nsAString& aType,

    37                                    bool aCanBubble,

    38                                    bool aCancelable,

    39                                    nsIDOMDataTransfer* aClipboardData)

    40 {

    41   nsCOMPtr<DataTransfer> clipboardData = do_QueryInterface(aClipboardData);

    42   // Null clipboardData is OK

    44   ErrorResult rv;

    45   InitClipboardEvent(aType, aCanBubble, aCancelable, clipboardData, rv);

    47   return rv.ErrorCode();

    48 }

    50 void

    51 ClipboardEvent::InitClipboardEvent(const nsAString& aType, bool aCanBubble,

    52                                    bool aCancelable,

    53                                    DataTransfer* aClipboardData,

    54                                    ErrorResult& aError)

    55 {

    56   aError = Event::InitEvent(aType, aCanBubble, aCancelable);

    57   if (aError.Failed()) {

    58     return;

    59   }

    61   mEvent->AsClipboardEvent()->clipboardData = aClipboardData;

    62 }

    64 already_AddRefed<ClipboardEvent>

    65 ClipboardEvent::Constructor(const GlobalObject& aGlobal,

    66                             const nsAString& aType,

    67                             const ClipboardEventInit& aParam,

    68                             ErrorResult& aRv)

    69 {

    70   nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());

    71   nsRefPtr<ClipboardEvent> e = new ClipboardEvent(t, nullptr, nullptr);

    72   bool trusted = e->Init(t);

    74   nsRefPtr<DataTransfer> clipboardData;

    75   if (e->mEventIsInternal) {

    76     InternalClipboardEvent* event = e->mEvent->AsClipboardEvent();

    77     if (event) {

    78       // Always create a clipboardData for the copy event. If this is changed to

    79       // support other types of events, make sure that read/write privileges are

    80       // checked properly within DataTransfer.

    81       clipboardData = new DataTransfer(ToSupports(e), NS_COPY, false, -1);

    82       clipboardData->SetData(aParam.mDataType, aParam.mData);

    83     }

    84   }

    86   e->InitClipboardEvent(aType, aParam.mBubbles, aParam.mCancelable,

    87                         clipboardData, aRv);

    88   e->SetTrusted(trusted);

    89   return e.forget();

    90 }

    92 NS_IMETHODIMP

    93 ClipboardEvent::GetClipboardData(nsIDOMDataTransfer** aClipboardData)

    94 {

    95   NS_IF_ADDREF(*aClipboardData = GetClipboardData());

    96   return NS_OK;

    97 }

    99 DataTransfer*

   100 ClipboardEvent::GetClipboardData()

   101 {

   102   InternalClipboardEvent* event = mEvent->AsClipboardEvent();

   104   if (!event->clipboardData) {

   105     if (mEventIsInternal) {

   106       event->clipboardData =

   107         new DataTransfer(ToSupports(this), NS_COPY, false, -1);

   108     } else {

   109       event->clipboardData =

   110         new DataTransfer(ToSupports(this), event->message,

   111                          event->message == NS_PASTE,

   112                          nsIClipboard::kGlobalClipboard);

   113     }

   114   }

   116   return event->clipboardData;

   117 }

   119 } // namespace dom

   120 } // namespace mozilla

   122 using namespace mozilla;

   123 using namespace mozilla::dom;

   125 nsresult

   126 NS_NewDOMClipboardEvent(nsIDOMEvent** aInstancePtrResult,

   127                         EventTarget* aOwner,

   128                         nsPresContext* aPresContext,

   129                         InternalClipboardEvent* aEvent)

   130 {

   131   ClipboardEvent* it = new ClipboardEvent(aOwner, aPresContext, aEvent);

   132   NS_ADDREF(it);

   133   *aInstancePtrResult = static_cast<Event*>(it);

   134   return NS_OK;

   135 }

The Tor Browser / file revision

dom/events/ClipboardEvent.cpp@97036ab72558

dom/events/ClipboardEvent.cpp