The Tor Browser: toolkit/components/finalizationwitness/FinalizationWitnessService.cpp@129ffea94266 (annotated)

toolkit/components/finalizationwitness/FinalizationWitnessService.cpp@129ffea94266 (annotated)

toolkit/components/finalizationwitness/FinalizationWitnessService.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* 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 "FinalizationWitnessService.h"
 #include "nsString.h"
 #include "jsapi.h"
 #include "js/CallNonGenericMethod.h"
 #include "mozJSComponentLoader.h"
 #include "nsZipArchive.h"
 #include "mozilla/Scoped.h"
 #include "mozilla/Services.h"
 #include "mozilla/NullPtr.h"
 #include "nsIObserverService.h"
 #include "nsThreadUtils.h"
 // Implementation of nsIFinalizationWitnessService
 namespace mozilla {
 namespace {
 /**
  * An event meant to be dispatched to the main thread upon finalization
  * of a FinalizationWitness, unless method |forget()| has been called.
  *
  * Held as private data by each instance of FinalizationWitness.
  * Important note: we maintain the invariant that these private data
  * slots are already addrefed.
  */
 class FinalizationEvent MOZ_FINAL: public nsRunnable
 {
 public:
   FinalizationEvent(const char* aTopic,
                   const jschar* aValue)
     : mTopic(aTopic)
     , mValue(aValue)
   { }
   NS_METHOD Run() {
     nsCOMPtr<nsIObserverService> observerService =
       mozilla::services::GetObserverService();
     if (!observerService) {
       // This is either too early or, more likely, too late for notifications.
       // Bail out.
       return NS_ERROR_NOT_AVAILABLE;
     }
     (void)observerService->
       NotifyObservers(nullptr, mTopic.get(), mValue.get());
     return NS_OK;
   }
 private:
   /**
    * The topic on which to broadcast the notification of finalization.
    *
    * Deallocated on the main thread.
    */
   const nsCString mTopic;
   /**
    * The result of converting the exception to a string.
    *
    * Deallocated on the main thread.
    */
   const nsString mValue;
 };
 enum {
   WITNESS_SLOT_EVENT,
   WITNESS_INSTANCES_SLOTS
 };
 /**
  * Extract the FinalizationEvent from an instance of FinalizationWitness
  * and clear the slot containing the FinalizationEvent.
  */
 already_AddRefed<FinalizationEvent>
 ExtractFinalizationEvent(JSObject *objSelf)
 {
   JS::Value slotEvent = JS_GetReservedSlot(objSelf, WITNESS_SLOT_EVENT);
   if (slotEvent.isUndefined()) {
     // Forget() has been called
     return nullptr;
   }
   JS_SetReservedSlot(objSelf, WITNESS_SLOT_EVENT, JS::UndefinedValue());
   return dont_AddRef(static_cast<FinalizationEvent*>(slotEvent.toPrivate()));
 }
 /**
  * Finalizer for instances of FinalizationWitness.
  *
  * Unless method Forget() has been called, the finalizer displays an error
  * message.
  */
 void Finalize(JSFreeOp *fop, JSObject *objSelf)
 {
   nsRefPtr<FinalizationEvent> event = ExtractFinalizationEvent(objSelf);
   if (event == nullptr) {
     // Forget() has been called
     return;
   }
   // Notify observers. Since we are executed during garbage-collection,
   // we need to dispatch the notification to the main thread.
   (void)NS_DispatchToMainThread(event);
   // We may fail at dispatching to the main thread if we arrive too late
   // during shutdown. In that case, there is not much we can do.
 }
 static const JSClass sWitnessClass = {
   "FinalizationWitness",
   JSCLASS_HAS_RESERVED_SLOTS(WITNESS_INSTANCES_SLOTS),
   JS_PropertyStub /* addProperty */,
   JS_DeletePropertyStub /* delProperty */,
   JS_PropertyStub /* getProperty */,
   JS_StrictPropertyStub /* setProperty */,
   JS_EnumerateStub /* enumerate */,
   JS_ResolveStub /* resolve */,
   JS_ConvertStub /* convert */,
   Finalize /* finalize */
 };
 bool IsWitness(JS::Handle<JS::Value> v)
 {
   return v.isObject() && JS_GetClass(&v.toObject()) == &sWitnessClass;
 }
 /**
  * JS method |forget()|
  *
  * === JS documentation
  *
  *  Neutralize the witness. Once this method is called, the witness will
  *  never report any error.
  */
 bool ForgetImpl(JSContext* cx, JS::CallArgs args)
 {
   if (args.length() != 0) {
     JS_ReportError(cx, "forget() takes no arguments");
     return false;
   }
   JS::Rooted<JS::Value> valSelf(cx, args.thisv());
   JS::Rooted<JSObject*> objSelf(cx, &valSelf.toObject());
   nsRefPtr<FinalizationEvent> event = ExtractFinalizationEvent(objSelf);
   if (event == nullptr) {
     JS_ReportError(cx, "forget() called twice");
     return false;
   }
   args.rval().setUndefined();
   return true;
 }
 bool Forget(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JS::CallArgs args = CallArgsFromVp(argc, vp);
   return JS::CallNonGenericMethod<IsWitness, ForgetImpl>(cx, args);
 }
 static const JSFunctionSpec sWitnessClassFunctions[] = {
   JS_FN("forget", Forget, 0, JSPROP_READONLY | JSPROP_PERMANENT),
   JS_FS_END
 };
 }
 NS_IMPL_ISUPPORTS(FinalizationWitnessService, nsIFinalizationWitnessService)
 /**
  * Create a new Finalization Witness.
  *
  * A finalization witness is an object whose sole role is to notify
  * observers when it is gc-ed. Once the witness is created, call its
  * method |forget()| to prevent the observers from being notified.
  *
  * @param aTopic The notification topic.
  * @param aValue The notification value. Converted to a string.
  *
  * @constructor
  */
 NS_IMETHODIMP
 FinalizationWitnessService::Make(const char* aTopic,
                                  const char16_t* aValue,
                                  JSContext* aCx,
                                  JS::MutableHandle<JS::Value> aRetval)
 {
   JS::Rooted<JSObject*> objResult(aCx, JS_NewObject(aCx, &sWitnessClass, JS::NullPtr(),
                                                     JS::NullPtr()));
   if (!objResult) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   if (!JS_DefineFunctions(aCx, objResult, sWitnessClassFunctions)) {
     return NS_ERROR_FAILURE;
   }
   nsRefPtr<FinalizationEvent> event = new FinalizationEvent(aTopic, aValue);
   // Transfer ownership of the addrefed |event| to |objResult|.
   JS_SetReservedSlot(objResult, WITNESS_SLOT_EVENT,
                      JS::PrivateValue(event.forget().take()));
   aRetval.setObject(*objResult);
   return NS_OK;
 }
 } // namespace mozilla

The Tor Browser / annotate

toolkit/components/finalizationwitness/FinalizationWitnessService.cpp@129ffea94266 (annotated)

toolkit/components/finalizationwitness/FinalizationWitnessService.cpp