The Tor Browser: xpcom/glue/BlockingResourceBase.h@129ffea94266 (annotated)

xpcom/glue/BlockingResourceBase.h@129ffea94266 (annotated)

xpcom/glue/BlockingResourceBase.h

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.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: sw=4 ts=4 et :
  * 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/. */
 #ifndef mozilla_BlockingResourceBase_h
 #define mozilla_BlockingResourceBase_h
 #include "prlog.h"
 #include "nscore.h"
 #include "nsDebug.h"
 #include "nsError.h"
 #include "nsISupportsImpl.h"
 #ifdef DEBUG
 #include "prinit.h"
 #include "prthread.h"
 #include "nsStringGlue.h"
 #include "mozilla/DeadlockDetector.h"
 #include "nsXPCOM.h"
 #endif
 //
 // This header is not meant to be included by client code.
 //
 namespace mozilla {
 /**
  * BlockingResourceBase
  * Base class of resources that might block clients trying to acquire them.
  * Does debugging and deadlock detection in DEBUG builds.
  **/
 class NS_COM_GLUE BlockingResourceBase
 {
 public:
     // Needs to be kept in sync with kResourceTypeNames.
     enum BlockingResourceType { eMutex, eReentrantMonitor, eCondVar };
     /**
      * kResourceTypeName
      * Human-readable version of BlockingResourceType enum.
      */
     static const char* const kResourceTypeName[];
 #ifdef DEBUG
 private:
     // forward declaration for the following typedef
     struct DeadlockDetectorEntry;
     // ``DDT'' = ``Deadlock Detector Type''
     typedef DeadlockDetector<DeadlockDetectorEntry> DDT;
     /**
      * DeadlockDetectorEntry
      * We free BlockingResources, but we never free entries in the
      * deadlock detector.  This struct outlives its BlockingResource
      * and preserves all the state needed to print subsequent
      * error messages.
      *
      * These objects are owned by the deadlock detector.
      */
     struct DeadlockDetectorEntry
     {
         DeadlockDetectorEntry(const char* aName,
                               BlockingResourceType aType) :
             mName(aName),
             mType(aType),
             mAcquisitionContext(CallStack::kNone)
         {
             NS_ABORT_IF_FALSE(mName, "Name must be nonnull");
         }
         /**
          * Print
          * Write a description of this blocking resource to |out|.  If
          * the resource appears to be currently acquired, the current
          * acquisition context is printed and true is returned.
          * Otherwise, we print the context from |aFirstSeen|, the
          * first acquisition from which the code calling |Print()|
          * became interested in us, and return false.  |Print()| can
          * be forced to print the context from |aFirstSeen| regardless
          * by passing |aPrintFirstSeenCx=true|.
          *
          * *NOT* thread safe.  Reads |mAcquisitionContext| without
          * synchronization, but this will not cause correctness
          * problems.
          *
          * FIXME bug 456272: hack alert: because we can't write call
          * contexts into strings, all info is written to stderr, but
          * only some info is written into |out|
          */
         bool Print(const DDT::ResourceAcquisition& aFirstSeen,
                    nsACString& out,
                    bool aPrintFirstSeenCx=false) const;
         /**
          * mName
          * A descriptive name for this resource.  Used in error
          * messages etc.
          */
         const char* mName;
         /**
          * mType
          * The more specific type of this resource.  Used to implement
          * special semantics (e.g., reentrancy of monitors).
          **/
         BlockingResourceType mType;
         /**
          * mAcquisitionContext
          * The calling context from which this resource was acquired, or
          * |CallStack::kNone| if it is currently free (or freed).
          */
         CallStack mAcquisitionContext;
     };
 protected:
     /**
      * BlockingResourceBase
      * Initialize this blocking resource.  Also hooks the resource into
      * instrumentation code.
      *
      * Thread safe.
      *
      * @param aName A meaningful, unique name that can be used in
      *              error messages, et al.
      * @param aType The specific type of |this|, if any.
      **/
     BlockingResourceBase(const char* aName, BlockingResourceType aType);
     ~BlockingResourceBase();
     /**
      * CheckAcquire
      *
      * Thread safe.
      *
      * @param aCallContext the client's calling context from which the
      *        original acquisition request was made.
      **/
     void CheckAcquire(const CallStack& aCallContext);
     /**
      * Acquire
      *
      * *NOT* thread safe.  Requires ownership of underlying resource.
      *
      * @param aCallContext the client's calling context from which the
      *        original acquisition request was made.
      **/
     void Acquire(const CallStack& aCallContext); //NS_NEEDS_RESOURCE(this)
     /**
      * Release
      * Remove this resource from the current thread's acquisition chain.
      * The resource does not have to be at the front of the chain, although
      * it is confusing to release resources in a different order than they
      * are acquired.  This generates a warning.
      *
      * *NOT* thread safe.  Requires ownership of underlying resource.
      **/
     void Release();             //NS_NEEDS_RESOURCE(this)
     /**
      * PrintCycle
      * Append to |out| detailed information about the circular
      * dependency in |cycle|.  Returns true if it *appears* that this
      * cycle may represent an imminent deadlock, but this is merely a
      * heuristic; the value returned may be a false positive or false
      * negative.
      *
      * *NOT* thread safe.  Calls |Print()|.
      *
      * FIXME bug 456272 hack alert: because we can't write call
      * contexts into strings, all info is written to stderr, but only
      * some info is written into |out|
      */
     static bool PrintCycle(const DDT::ResourceAcquisitionArray* cycle,
                            nsACString& out);
     /**
      * ResourceChainFront
      *
      * Thread safe.
      *
      * @return the front of the resource acquisition chain, i.e., the last
      *         resource acquired.
      */
     static BlockingResourceBase* ResourceChainFront()
     {
         return (BlockingResourceBase*)
             PR_GetThreadPrivate(sResourceAcqnChainFrontTPI);
     }
     /**
      * ResourceChainPrev
      *
      * *NOT* thread safe.  Requires ownership of underlying resource.
      */
     static BlockingResourceBase*
     ResourceChainPrev(const BlockingResourceBase* aResource)
     {
         return aResource->mChainPrev;
     } //NS_NEEDS_RESOURCE(this)
     /**
      * ResourceChainAppend
      * Set |this| to the front of the resource acquisition chain, and link
      * |this| to |aPrev|.
      *
      * *NOT* thread safe.  Requires ownership of underlying resource.
      */
     void ResourceChainAppend(BlockingResourceBase* aPrev)
     {
         mChainPrev = aPrev;
         PR_SetThreadPrivate(sResourceAcqnChainFrontTPI, this);
     } //NS_NEEDS_RESOURCE(this)
     /**
      * ResourceChainRemove
      * Remove |this| from the front of the resource acquisition chain.
      *
      * *NOT* thread safe.  Requires ownership of underlying resource.
      */
     void ResourceChainRemove()
     {
         NS_ASSERTION(this == ResourceChainFront(), "not at chain front");
         PR_SetThreadPrivate(sResourceAcqnChainFrontTPI, mChainPrev);
     } //NS_NEEDS_RESOURCE(this)
     /**
      * GetAcquisitionContext
      * Return the calling context from which this resource was acquired,
      * or CallStack::kNone if it's currently free.
      *
      * *NOT* thread safe.  Requires ownership of underlying resource.
      */
     CallStack
     GetAcquisitionContext()
     {
         return mDDEntry->mAcquisitionContext;
     }
     /**
      * SetAcquisitionContext
      * Set the calling context from which this resource was acquired.
      *
      * *NOT* thread safe.  Requires ownership of underlying resource.
      */
     void
     SetAcquisitionContext(CallStack aAcquisitionContext)
     {
         mDDEntry->mAcquisitionContext = aAcquisitionContext;
     }
     /**
      * mChainPrev
      * A series of resource acquisitions creates a chain of orders.  This
      * chain is implemented as a linked list; |mChainPrev| points to the
      * resource most recently Acquire()'d before this one.
      **/
     BlockingResourceBase* mChainPrev;
 private:
     /**
      * mDDEntry
      * The key for this BlockingResourceBase in the deadlock detector.
      */
     DeadlockDetectorEntry* mDDEntry;
     /**
      * sCallOnce
      * Ensures static members are initialized only once, and in a
      * thread-safe way.
      */
     static PRCallOnceType sCallOnce;
     /**
      * sResourceAcqnChainFrontTPI
      * Thread-private index to the front of each thread's resource
      * acquisition chain.
      */
     static unsigned sResourceAcqnChainFrontTPI;
     /**
      * sDeadlockDetector
      * Does as named.
      */
     static DDT* sDeadlockDetector;
     /**
      * InitStatics
      * Inititialize static members of BlockingResourceBase that can't
      * be statically initialized.
      *
      * *NOT* thread safe.
      */
     static PRStatus InitStatics() {
         PR_NewThreadPrivateIndex(&sResourceAcqnChainFrontTPI, 0);
         sDeadlockDetector = new DDT();
         if (!sDeadlockDetector)
             NS_RUNTIMEABORT("can't allocate deadlock detector");
         return PR_SUCCESS;
     }
     /**
      * Shutdown
      * Free static members.
      *
      * *NOT* thread safe.
      */
     static void Shutdown() {
         delete sDeadlockDetector;
         sDeadlockDetector = 0;
     }
 #  ifdef MOZILLA_INTERNAL_API
     // so it can call BlockingResourceBase::Shutdown()
     friend void LogTerm();
 #  endif  // ifdef MOZILLA_INTERNAL_API
 #else  // non-DEBUG implementation
     BlockingResourceBase(const char* aName, BlockingResourceType aType)
     {
     }
     ~BlockingResourceBase()
     {
     }
 #endif
 };
 } // namespace mozilla
 #endif // mozilla_BlockingResourceBase_h

The Tor Browser / annotate

xpcom/glue/BlockingResourceBase.h@129ffea94266 (annotated)

xpcom/glue/BlockingResourceBase.h