The Tor Browser: content/xul/templates/src/nsRDFBinding.h@129ffea94266 (annotated)

content/xul/templates/src/nsRDFBinding.h@129ffea94266 (annotated)

content/xul/templates/src/nsRDFBinding.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 -*- */
 /* 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 nsRDFBinding_h__
 #define nsRDFBinding_h__
 #include "nsAutoPtr.h"
 #include "nsIAtom.h"
 #include "nsIRDFResource.h"
 #include "nsISupportsImpl.h"
 class nsXULTemplateResultRDF;
 class nsBindingValues;
 /*
  * Classes related to storing bindings for RDF handling.
  */
 /*
  * a  <binding> descriptors
  */
 class RDFBinding {
 public:
     nsCOMPtr<nsIAtom>        mSubjectVariable;
     nsCOMPtr<nsIRDFResource> mPredicate;
     nsCOMPtr<nsIAtom>        mTargetVariable;
     // indicates whether a binding is dependant on the result from a
     // previous binding
     bool                     mHasDependency;
     RDFBinding*              mNext;
 private:
     friend class RDFBindingSet;
     RDFBinding(nsIAtom* aSubjectVariable,
                nsIRDFResource* aPredicate,
                nsIAtom* aTargetVariable)
       : mSubjectVariable(aSubjectVariable),
         mPredicate(aPredicate),
         mTargetVariable(aTargetVariable),
         mHasDependency(false),
         mNext(nullptr)
     {
         MOZ_COUNT_CTOR(RDFBinding);
     }
     ~RDFBinding()
     {
         MOZ_COUNT_DTOR(RDFBinding);
     }
 };
 /*
  * a collection of <binding> descriptors. This object is refcounted by
  * nsBindingValues objects and the query processor.
  */
 class RDFBindingSet MOZ_FINAL
 {
 private:
     // Private destructor, to discourage deletion outside of Release():
     ~RDFBindingSet();
     // the number of bindings
     int32_t mCount;
     // pointer to the first binding in a linked list
     RDFBinding* mFirst;
 public:
     RDFBindingSet()
         : mCount(0),
           mFirst(nullptr)
     {
         MOZ_COUNT_CTOR(RDFBindingSet);
     }
     NS_INLINE_DECL_REFCOUNTING(RDFBindingSet)
     int32_t Count() const { return mCount; }
     /*
      * Add a binding (aRef -> aPredicate -> aVar) to the set
      */
     nsresult
     AddBinding(nsIAtom* aVar, nsIAtom* aRef, nsIRDFResource* aPredicate);
     /*
      * Return true if the binding set contains a binding which would cause
      * the result to need resynchronizing for an RDF triple. The member
      * variable may be supplied as an optimization since bindings most
      * commonly use the member variable as the subject. If aMemberVariable
      * is set, aSubject must be the value of the member variable for the
      * result. The supplied binding values aBindingValues must be values
      * using this binding set (that is aBindingValues->GetBindingSet() == this)
      *
      * @param aSubject subject of the RDF triple
      * @param aPredicate predicate of the RDF triple
      * @param aTarget target of the RDF triple
      * @param aMemberVariable member variable for the query for the binding
      * @param aResult result to synchronize
      * @param aBindingValues the values for the bindings for the result
      */
     bool
     SyncAssignments(nsIRDFResource* aSubject,
                     nsIRDFResource* aPredicate,
                     nsIRDFNode* aTarget,
                     nsIAtom* aMemberVariable,
                     nsXULTemplateResultRDF* aResult,
                     nsBindingValues& aBindingValues);
     /*
      * The query processor maintains a map of subjects to an array of results.
      * This is used such that when a new assertion is added to the RDF graph,
      * the results associated with the subject of that triple may be checked
      * to see if their bindings have changed. The AddDependencies method adds
      * these subject dependencies to the map.
      */
     void
     AddDependencies(nsIRDFResource* aSubject,
                     nsXULTemplateResultRDF* aResult);
     /*
      * Remove the results from the dependencies map when results are deleted.
      */
     void
     RemoveDependencies(nsIRDFResource* aSubject,
                        nsXULTemplateResultRDF* aResult);
     /*
      * The nsBindingValues classes stores an array of values, one for each
      * target symbol that could be set by the bindings in the set.
      * LookupTargetIndex determines the index into the array for a given
      * target symbol.
      */
     int32_t
     LookupTargetIndex(nsIAtom* aTargetVariable, RDFBinding** aBinding);
 };
 /*
  * A set of values of bindings. This object is used once per result.
  * This stores a reference to the binding set and an array of node values.
  * Since the binding set is used once per query and the values are
  * used once per result, we reduce size by only storing the value array's
  * length in the binding set. This is possible since the array is always
  * a fixed length for a particular binding set.
  *
  * XXX ndeakin We may want to revisit this later since it makes the code
  *             more complicated.
  */
 class nsBindingValues
 {
 protected:
     // the binding set
     nsRefPtr<RDFBindingSet> mBindings;
     /*
      * A set of values for variable bindings. To look up a binding value,
      * scan through the binding set in mBindings for the right target atom.
      * Its index will correspond to the index in this array. The size of this
      * array is determined by the RDFBindingSet's Count().
      */
     nsCOMPtr<nsIRDFNode>* mValues;
 public:
     nsBindingValues()
       : mBindings(nullptr),
         mValues(nullptr)
     {
         MOZ_COUNT_CTOR(nsBindingValues);
     }
     ~nsBindingValues();
     /**
      * Clear the binding set, to be called when the nsBindingValues is deleted
      * or a new binding set is being set.
      */
     void ClearBindingSet();
     RDFBindingSet* GetBindingSet() { return mBindings; }
     /**
      * Set the binding set to use. This needs to be called once a rule matches
      * since it is then known which bindings will apply.
      */
     nsresult SetBindingSet(RDFBindingSet* aBindings);
     nsCOMPtr<nsIRDFNode>* ValuesArray() { return mValues; }
     /*
      * Retrieve the assignment for a particular variable
      */
     void
     GetAssignmentFor(nsXULTemplateResultRDF* aResult,
                      nsIAtom* aVar,
                      nsIRDFNode** aValue);
     /*
      * Remove depenedencies the bindings have on particular resources
      */
     void
     RemoveDependencies(nsIRDFResource* aSubject,
                        nsXULTemplateResultRDF* aResult);
 };
 #endif // nsRDFBinding_h__

The Tor Browser / annotate

content/xul/templates/src/nsRDFBinding.h@129ffea94266 (annotated)

content/xul/templates/src/nsRDFBinding.h