The Tor Browser: dom/smil/nsSMILTimeValueSpec.cpp@97036ab72558 (annotated)

dom/smil/nsSMILTimeValueSpec.cpp@97036ab72558 (annotated)

dom/smil/nsSMILTimeValueSpec.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

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.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/dom/SVGAnimationElement.h"
 #include "nsSMILTimeValueSpec.h"
 #include "nsSMILInterval.h"
 #include "nsSMILTimeContainer.h"
 #include "nsSMILTimeValue.h"
 #include "nsSMILTimedElement.h"
 #include "nsSMILInstanceTime.h"
 #include "nsSMILParserUtils.h"
 #include "nsIDOMKeyEvent.h"
 #include "nsIDOMTimeEvent.h"
 #include "nsString.h"
 #include <limits>
 using namespace mozilla;
 using namespace mozilla::dom;
 //----------------------------------------------------------------------
 // Nested class: EventListener
 NS_IMPL_ISUPPORTS(nsSMILTimeValueSpec::EventListener, nsIDOMEventListener)
 NS_IMETHODIMP
 nsSMILTimeValueSpec::EventListener::HandleEvent(nsIDOMEvent* aEvent)
 {
   if (mSpec) {
     mSpec->HandleEvent(aEvent);
   }
   return NS_OK;
 }
 //----------------------------------------------------------------------
 // Implementation
 nsSMILTimeValueSpec::nsSMILTimeValueSpec(nsSMILTimedElement& aOwner,
                                          bool aIsBegin)
   : mOwner(&aOwner),
     mIsBegin(aIsBegin),
     mReferencedElement(MOZ_THIS_IN_INITIALIZER_LIST())
 {
 }
 nsSMILTimeValueSpec::~nsSMILTimeValueSpec()
 {
   UnregisterFromReferencedElement(mReferencedElement.get());
   if (mEventListener) {
     mEventListener->Disconnect();
     mEventListener = nullptr;
   }
 }
 nsresult
 nsSMILTimeValueSpec::SetSpec(const nsAString& aStringSpec,
                              Element* aContextNode)
 {
   nsSMILTimeValueSpecParams params;
   if (!nsSMILParserUtils::ParseTimeValueSpecParams(aStringSpec, params))
     return NS_ERROR_FAILURE;
   mParams = params;
   // According to SMIL 3.0:
   //   The special value "indefinite" does not yield an instance time in the
   //   begin list. It will, however yield a single instance with the value
   //   "indefinite" in an end list. This value is not removed by a reset.
   if (mParams.mType == nsSMILTimeValueSpecParams::OFFSET ||
       (!mIsBegin && mParams.mType == nsSMILTimeValueSpecParams::INDEFINITE)) {
     mOwner->AddInstanceTime(new nsSMILInstanceTime(mParams.mOffset), mIsBegin);
   }
   // Fill in the event symbol to simplify handling later
   if (mParams.mType == nsSMILTimeValueSpecParams::REPEAT) {
     mParams.mEventSymbol = nsGkAtoms::repeatEvent;
   } else if (mParams.mType == nsSMILTimeValueSpecParams::ACCESSKEY) {
     mParams.mEventSymbol = nsGkAtoms::keypress;
   }
   ResolveReferences(aContextNode);
   return NS_OK;
 }
 void
 nsSMILTimeValueSpec::ResolveReferences(nsIContent* aContextNode)
 {
   if (mParams.mType != nsSMILTimeValueSpecParams::SYNCBASE && !IsEventBased())
     return;
   NS_ABORT_IF_FALSE(aContextNode,
       "null context node for resolving timing references against");
   // If we're not bound to the document yet, don't worry, we'll get called again
   // when that happens
   if (!aContextNode->IsInDoc())
     return;
   // Hold ref to the old element so that it isn't destroyed in between resetting
   // the referenced element and using the pointer to update the referenced
   // element.
   nsRefPtr<Element> oldReferencedElement = mReferencedElement.get();
   if (mParams.mDependentElemID) {
     mReferencedElement.ResetWithID(aContextNode,
         nsDependentAtomString(mParams.mDependentElemID));
   } else if (mParams.mType == nsSMILTimeValueSpecParams::EVENT) {
     Element* target = mOwner->GetTargetElement();
     mReferencedElement.ResetWithElement(target);
   } else if (mParams.mType == nsSMILTimeValueSpecParams::ACCESSKEY) {
     nsIDocument* doc = aContextNode->GetCurrentDoc();
     NS_ABORT_IF_FALSE(doc, "We are in the document but current doc is null");
     mReferencedElement.ResetWithElement(doc->GetRootElement());
   } else {
     NS_ABORT_IF_FALSE(false, "Syncbase or repeat spec without ID");
   }
   UpdateReferencedElement(oldReferencedElement, mReferencedElement.get());
 }
 bool
 nsSMILTimeValueSpec::IsEventBased() const
 {
   return mParams.mType == nsSMILTimeValueSpecParams::EVENT ||
          mParams.mType == nsSMILTimeValueSpecParams::REPEAT ||
          mParams.mType == nsSMILTimeValueSpecParams::ACCESSKEY;
 }
 void
 nsSMILTimeValueSpec::HandleNewInterval(nsSMILInterval& aInterval,
                                        const nsSMILTimeContainer* aSrcContainer)
 {
   const nsSMILInstanceTime& baseInstance = mParams.mSyncBegin
     ? *aInterval.Begin() : *aInterval.End();
   nsSMILTimeValue newTime =
     ConvertBetweenTimeContainers(baseInstance.Time(), aSrcContainer);
   // Apply offset
   if (!ApplyOffset(newTime)) {
     NS_WARNING("New time overflows nsSMILTime, ignoring");
     return;
   }
   // Create the instance time and register it with the interval
   nsRefPtr<nsSMILInstanceTime> newInstance =
     new nsSMILInstanceTime(newTime, nsSMILInstanceTime::SOURCE_SYNCBASE, this,
                            &aInterval);
   mOwner->AddInstanceTime(newInstance, mIsBegin);
 }
 void
 nsSMILTimeValueSpec::HandleTargetElementChange(Element* aNewTarget)
 {
   if (!IsEventBased() || mParams.mDependentElemID)
     return;
   mReferencedElement.ResetWithElement(aNewTarget);
 }
 void
 nsSMILTimeValueSpec::HandleChangedInstanceTime(
     const nsSMILInstanceTime& aBaseTime,
     const nsSMILTimeContainer* aSrcContainer,
     nsSMILInstanceTime& aInstanceTimeToUpdate,
     bool aObjectChanged)
 {
   // If the instance time is fixed (e.g. because it's being used as the begin
   // time of an active or postactive interval) we just ignore the change.
   if (aInstanceTimeToUpdate.IsFixedTime())
     return;
   nsSMILTimeValue updatedTime =
     ConvertBetweenTimeContainers(aBaseTime.Time(), aSrcContainer);
   // Apply offset
   if (!ApplyOffset(updatedTime)) {
     NS_WARNING("Updated time overflows nsSMILTime, ignoring");
     return;
   }
   // The timed element that owns the instance time does the updating so it can
   // re-sort its array of instance times more efficiently
   if (aInstanceTimeToUpdate.Time() != updatedTime || aObjectChanged) {
     mOwner->UpdateInstanceTime(&aInstanceTimeToUpdate, updatedTime, mIsBegin);
   }
 }
 void
 nsSMILTimeValueSpec::HandleDeletedInstanceTime(
     nsSMILInstanceTime &aInstanceTime)
 {
   mOwner->RemoveInstanceTime(&aInstanceTime, mIsBegin);
 }
 bool
 nsSMILTimeValueSpec::DependsOnBegin() const
 {
   return mParams.mSyncBegin;
 }
 void
 nsSMILTimeValueSpec::Traverse(nsCycleCollectionTraversalCallback* aCallback)
 {
   mReferencedElement.Traverse(aCallback);
 }
 void
 nsSMILTimeValueSpec::Unlink()
 {
   UnregisterFromReferencedElement(mReferencedElement.get());
   mReferencedElement.Unlink();
 }
 //----------------------------------------------------------------------
 // Implementation helpers
 void
 nsSMILTimeValueSpec::UpdateReferencedElement(Element* aFrom, Element* aTo)
 {
   if (aFrom == aTo)
     return;
   UnregisterFromReferencedElement(aFrom);
   switch (mParams.mType)
   {
   case nsSMILTimeValueSpecParams::SYNCBASE:
     {
       nsSMILTimedElement* to = GetTimedElement(aTo);
       if (to) {
         to->AddDependent(*this);
       }
     }
     break;
   case nsSMILTimeValueSpecParams::EVENT:
   case nsSMILTimeValueSpecParams::REPEAT:
   case nsSMILTimeValueSpecParams::ACCESSKEY:
     RegisterEventListener(aTo);
     break;
   default:
     // not a referencing-type
     break;
   }
 }
 void
 nsSMILTimeValueSpec::UnregisterFromReferencedElement(Element* aElement)
 {
   if (!aElement)
     return;
   if (mParams.mType == nsSMILTimeValueSpecParams::SYNCBASE) {
     nsSMILTimedElement* timedElement = GetTimedElement(aElement);
     if (timedElement) {
       timedElement->RemoveDependent(*this);
     }
     mOwner->RemoveInstanceTimesForCreator(this, mIsBegin);
   } else if (IsEventBased()) {
     UnregisterEventListener(aElement);
   }
 }
 nsSMILTimedElement*
 nsSMILTimeValueSpec::GetTimedElement(Element* aElement)
 {
   return aElement && aElement->IsNodeOfType(nsINode::eANIMATION) ?
     &static_cast<SVGAnimationElement*>(aElement)->TimedElement() : nullptr;
 }
 // Indicates whether we're allowed to register an event-listener
 // when scripting is disabled.
 bool
 nsSMILTimeValueSpec::IsWhitelistedEvent()
 {
   // The category of (SMIL-specific) "repeat(n)" events are allowed.
   if (mParams.mType == nsSMILTimeValueSpecParams::REPEAT) {
     return true;
   }
   // A specific list of other SMIL-related events are allowed, too.
   if (mParams.mType == nsSMILTimeValueSpecParams::EVENT &&
       (mParams.mEventSymbol == nsGkAtoms::repeat ||
        mParams.mEventSymbol == nsGkAtoms::repeatEvent ||
        mParams.mEventSymbol == nsGkAtoms::beginEvent ||
        mParams.mEventSymbol == nsGkAtoms::endEvent)) {
     return true;
   }
   return false;
 }
 void
 nsSMILTimeValueSpec::RegisterEventListener(Element* aTarget)
 {
   NS_ABORT_IF_FALSE(IsEventBased(),
     "Attempting to register event-listener for unexpected nsSMILTimeValueSpec"
     " type");
   NS_ABORT_IF_FALSE(mParams.mEventSymbol,
     "Attempting to register event-listener but there is no event name");
   if (!aTarget)
     return;
   // When script is disabled, only allow registration for whitelisted events.
   if (!aTarget->GetOwnerDocument()->IsScriptEnabled() &&
       !IsWhitelistedEvent()) {
     return;
   }
   if (!mEventListener) {
     mEventListener = new EventListener(this);
   }
   EventListenerManager* elm = GetEventListenerManager(aTarget);
   if (!elm)
     return;
   elm->AddEventListenerByType(mEventListener,
                               nsDependentAtomString(mParams.mEventSymbol),
                               AllEventsAtSystemGroupBubble());
 }
 void
 nsSMILTimeValueSpec::UnregisterEventListener(Element* aTarget)
 {
   if (!aTarget || !mEventListener)
     return;
   EventListenerManager* elm = GetEventListenerManager(aTarget);
   if (!elm)
     return;
   elm->RemoveEventListenerByType(mEventListener,
                                  nsDependentAtomString(mParams.mEventSymbol),
                                  AllEventsAtSystemGroupBubble());
 }
 EventListenerManager*
 nsSMILTimeValueSpec::GetEventListenerManager(Element* aTarget)
 {
   NS_ABORT_IF_FALSE(aTarget, "null target; can't get EventListenerManager");
   nsCOMPtr<EventTarget> target;
   if (mParams.mType == nsSMILTimeValueSpecParams::ACCESSKEY) {
     nsIDocument* doc = aTarget->GetCurrentDoc();
     if (!doc)
       return nullptr;
     nsPIDOMWindow* win = doc->GetWindow();
     if (!win)
       return nullptr;
     target = do_QueryInterface(win);
   } else {
     target = aTarget;
   }
   if (!target)
     return nullptr;
   return target->GetOrCreateListenerManager();
 }
 void
 nsSMILTimeValueSpec::HandleEvent(nsIDOMEvent* aEvent)
 {
   NS_ABORT_IF_FALSE(mEventListener, "Got event without an event listener");
   NS_ABORT_IF_FALSE(IsEventBased(),
                     "Got event for non-event nsSMILTimeValueSpec");
   NS_ABORT_IF_FALSE(aEvent, "No event supplied");
   // XXX In the long run we should get the time from the event itself which will
   // store the time in global document time which we'll need to convert to our
   // time container
   nsSMILTimeContainer* container = mOwner->GetTimeContainer();
   if (!container)
     return;
   if (!CheckEventDetail(aEvent))
     return;
   nsSMILTime currentTime = container->GetCurrentTime();
   nsSMILTimeValue newTime(currentTime);
   if (!ApplyOffset(newTime)) {
     NS_WARNING("New time generated from event overflows nsSMILTime, ignoring");
     return;
   }
   nsRefPtr<nsSMILInstanceTime> newInstance =
     new nsSMILInstanceTime(newTime, nsSMILInstanceTime::SOURCE_EVENT);
   mOwner->AddInstanceTime(newInstance, mIsBegin);
 }
 bool
 nsSMILTimeValueSpec::CheckEventDetail(nsIDOMEvent *aEvent)
 {
   switch (mParams.mType)
   {
   case nsSMILTimeValueSpecParams::REPEAT:
     return CheckRepeatEventDetail(aEvent);
   case nsSMILTimeValueSpecParams::ACCESSKEY:
     return CheckAccessKeyEventDetail(aEvent);
   default:
     // nothing to check
     return true;
   }
 }
 bool
 nsSMILTimeValueSpec::CheckRepeatEventDetail(nsIDOMEvent *aEvent)
 {
   nsCOMPtr<nsIDOMTimeEvent> timeEvent = do_QueryInterface(aEvent);
   if (!timeEvent) {
     NS_WARNING("Received a repeat event that was not a DOMTimeEvent");
     return false;
   }
   int32_t detail;
   timeEvent->GetDetail(&detail);
   return detail > 0 && (uint32_t)detail == mParams.mRepeatIterationOrAccessKey;
 }
 bool
 nsSMILTimeValueSpec::CheckAccessKeyEventDetail(nsIDOMEvent *aEvent)
 {
   nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aEvent);
   if (!keyEvent) {
     NS_WARNING("Received an accesskey event that was not a DOMKeyEvent");
     return false;
   }
   // Ignore the key event if any modifier keys are pressed UNLESS we're matching
   // on the charCode in which case we ignore the state of the shift and alt keys
   // since they might be needed to generate the character in question.
   bool isCtrl;
   bool isMeta;
   keyEvent->GetCtrlKey(&isCtrl);
   keyEvent->GetMetaKey(&isMeta);
   if (isCtrl || isMeta)
     return false;
   uint32_t code;
   keyEvent->GetCharCode(&code);
   if (code)
     return code == mParams.mRepeatIterationOrAccessKey;
   // Only match on the keyCode if it corresponds to some ASCII character that
   // does not produce a charCode.
   // In this case we can safely bail out if either alt or shift is pressed since
   // they won't already be incorporated into the keyCode unlike the charCode.
   bool isAlt;
   bool isShift;
   keyEvent->GetAltKey(&isAlt);
   keyEvent->GetShiftKey(&isShift);
   if (isAlt || isShift)
     return false;
   keyEvent->GetKeyCode(&code);
   switch (code)
   {
   case nsIDOMKeyEvent::DOM_VK_BACK_SPACE:
     return mParams.mRepeatIterationOrAccessKey == 0x08;
   case nsIDOMKeyEvent::DOM_VK_RETURN:
     return mParams.mRepeatIterationOrAccessKey == 0x0A ||
            mParams.mRepeatIterationOrAccessKey == 0x0D;
   case nsIDOMKeyEvent::DOM_VK_ESCAPE:
     return mParams.mRepeatIterationOrAccessKey == 0x1B;
   case nsIDOMKeyEvent::DOM_VK_DELETE:
     return mParams.mRepeatIterationOrAccessKey == 0x7F;
   default:
     return false;
   }
 }
 nsSMILTimeValue
 nsSMILTimeValueSpec::ConvertBetweenTimeContainers(
     const nsSMILTimeValue& aSrcTime,
     const nsSMILTimeContainer* aSrcContainer)
 {
   // If the source time is either indefinite or unresolved the result is going
   // to be the same
   if (!aSrcTime.IsDefinite())
     return aSrcTime;
   // Convert from source time container to our parent time container
   const nsSMILTimeContainer* dstContainer = mOwner->GetTimeContainer();
   if (dstContainer == aSrcContainer)
     return aSrcTime;
   // If one of the elements is not attached to a time container then we can't do
   // any meaningful conversion
   if (!aSrcContainer || !dstContainer)
     return nsSMILTimeValue(); // unresolved
   nsSMILTimeValue docTime =
     aSrcContainer->ContainerToParentTime(aSrcTime.GetMillis());
   if (docTime.IsIndefinite())
     // This will happen if the source container is paused and we have a future
     // time. Just return the indefinite time.
     return docTime;
   NS_ABORT_IF_FALSE(docTime.IsDefinite(),
     "ContainerToParentTime gave us an unresolved or indefinite time");
   return dstContainer->ParentToContainerTime(docTime.GetMillis());
 }
 bool
 nsSMILTimeValueSpec::ApplyOffset(nsSMILTimeValue& aTime) const
 {
   // indefinite + offset = indefinite. Likewise for unresolved times.
   if (!aTime.IsDefinite()) {
     return true;
   }
   double resultAsDouble =
     (double)aTime.GetMillis() + mParams.mOffset.GetMillis();
   if (resultAsDouble > std::numeric_limits<nsSMILTime>::max() ||
       resultAsDouble < std::numeric_limits<nsSMILTime>::min()) {
     return false;
   }
   aTime.SetMillis(aTime.GetMillis() + mParams.mOffset.GetMillis());
   return true;
 }

The Tor Browser / annotate

dom/smil/nsSMILTimeValueSpec.cpp@97036ab72558 (annotated)

dom/smil/nsSMILTimeValueSpec.cpp