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

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

content/xul/templates/src/nsRDFBinding.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.

 /* -*- 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/. */
 #include "nsXULTemplateQueryProcessorRDF.h"
 #include "nsXULTemplateResultRDF.h"
 #include "nsRDFBinding.h"
 #ifdef DEBUG
 #include "nsXULContentUtils.h"
 #endif
 RDFBindingSet::~RDFBindingSet()
 {
     while (mFirst) {
         RDFBinding* doomed = mFirst;
         mFirst = mFirst->mNext;
         delete doomed;
     }
     MOZ_COUNT_DTOR(RDFBindingSet);
 }
 nsresult
 RDFBindingSet::AddBinding(nsIAtom* aVar, nsIAtom* aRef, nsIRDFResource* aPredicate)
 {
     RDFBinding* newbinding = new RDFBinding(aRef, aPredicate, aVar);
     if (! newbinding)
         return NS_ERROR_OUT_OF_MEMORY;
     if (mFirst) {
         RDFBinding* binding = mFirst;
         while (binding) {
             // the binding is dependant on the calculation of a previous binding
             if (binding->mSubjectVariable == aVar)
                 newbinding->mHasDependency = true;
             // if the target variable is already used in a binding, ignore it
             // since it won't be useful for anything
             if (binding->mTargetVariable == aVar) {
                 delete newbinding;
                 return NS_OK;
             }
             // add the binding at the end of the list
             if (! binding->mNext) {
                 binding->mNext = newbinding;
                 break;
             }
             binding = binding->mNext;
         }
     }
     else {
         mFirst = newbinding;
     }
     mCount++;
     return NS_OK;
 }
 bool
 RDFBindingSet::SyncAssignments(nsIRDFResource* aSubject,
                                nsIRDFResource* aPredicate,
                                nsIRDFNode* aTarget,
                                nsIAtom* aMemberVariable,
                                nsXULTemplateResultRDF* aResult,
                                nsBindingValues& aBindingValues)
 {
     NS_ASSERTION(aBindingValues.GetBindingSet() == this,
                  "nsBindingValues not for this RDFBindingSet");
     NS_PRECONDITION(aResult, "Must have result");
     bool needSync = false;
     nsCOMPtr<nsIRDFNode>* valuesArray = aBindingValues.ValuesArray();
     if (!valuesArray)
         return false;
     RDFBinding* binding = mFirst;
     int32_t count = 0;
     // QI for proper comparisons just to be safe
     nsCOMPtr<nsIRDFNode> subjectnode = do_QueryInterface(aSubject);
     // iterate through the bindings looking for ones that would match the RDF
     // nodes that were involved in a change
     nsCOMPtr<nsIRDFNode> value;
     while (binding) {
         if (aPredicate == binding->mPredicate) {
             // if the source of the binding is the member variable, optimize
             if (binding->mSubjectVariable == aMemberVariable) {
                 valuesArray[count] = aTarget;
                 needSync = true;
             }
             else {
                 aResult->GetAssignment(binding->mSubjectVariable, getter_AddRefs(value));
                 if (value == subjectnode) {
                     valuesArray[count] = aTarget;
                     needSync = true;
                 }
             }
         }
         binding = binding->mNext;
         count++;
     }
     return needSync;
 }
 void
 RDFBindingSet::AddDependencies(nsIRDFResource* aSubject,
                                nsXULTemplateResultRDF* aResult)
 {
     NS_PRECONDITION(aResult, "Must have result");
     // iterate through the bindings and add binding dependencies to the
     // processor
     nsXULTemplateQueryProcessorRDF* processor = aResult->GetProcessor();
     if (! processor)
         return;
     nsCOMPtr<nsIRDFNode> value;
     RDFBinding* binding = mFirst;
     while (binding) {
         aResult->GetAssignment(binding->mSubjectVariable, getter_AddRefs(value));
         nsCOMPtr<nsIRDFResource> valueres = do_QueryInterface(value);
         if (valueres)
             processor->AddBindingDependency(aResult, valueres);
         binding = binding->mNext;
     }
 }
 void
 RDFBindingSet::RemoveDependencies(nsIRDFResource* aSubject,
                                   nsXULTemplateResultRDF* aResult)
 {
     NS_PRECONDITION(aResult, "Must have result");
     // iterate through the bindings and remove binding dependencies from the
     // processor
     nsXULTemplateQueryProcessorRDF* processor = aResult->GetProcessor();
     if (! processor)
         return;
     nsCOMPtr<nsIRDFNode> value;
     RDFBinding* binding = mFirst;
     while (binding) {
         aResult->GetAssignment(binding->mSubjectVariable, getter_AddRefs(value));
         nsCOMPtr<nsIRDFResource> valueres = do_QueryInterface(value);
         if (valueres)
             processor->RemoveBindingDependency(aResult, valueres);
         binding = binding->mNext;
     }
 }
 int32_t
 RDFBindingSet::LookupTargetIndex(nsIAtom* aTargetVariable, RDFBinding** aBinding)
 {
     int32_t idx = 0;
     RDFBinding* binding = mFirst;
     while (binding) {
         if (binding->mTargetVariable == aTargetVariable) {
             *aBinding = binding;
             return idx;
         }
         idx++;
         binding = binding->mNext;
     }
     return -1;
 }
 nsBindingValues::~nsBindingValues()
 {
     ClearBindingSet();
     MOZ_COUNT_DTOR(nsBindingValues);
 }
 void
 nsBindingValues::ClearBindingSet()
 {
     if (mBindings && mValues) {
         delete [] mValues;
         mValues = nullptr;
     }
     mBindings = nullptr;
 }
 nsresult
 nsBindingValues::SetBindingSet(RDFBindingSet* aBindings)
 {
     ClearBindingSet();
     int32_t count = aBindings->Count();
     if (count) {
         mValues = new nsCOMPtr<nsIRDFNode>[count];
         if (!mValues)
             return NS_ERROR_OUT_OF_MEMORY;
         mBindings = aBindings;
     }
     else {
         mValues = nullptr;
     }
     return NS_OK;
 }
 void
 nsBindingValues::GetAssignmentFor(nsXULTemplateResultRDF* aResult,
                                   nsIAtom* aVar,
                                   nsIRDFNode** aValue)
 {
     *aValue = nullptr;
     // assignments are calculated lazily when asked for. The only issue is
     // when a binding has no value in the RDF graph, it will be checked again
     // every time.
     if (mBindings && mValues) {
         RDFBinding* binding;
         int32_t idx = mBindings->LookupTargetIndex(aVar, &binding);
         if (idx >= 0) {
             *aValue = mValues[idx];
             if (*aValue) {
                 NS_ADDREF(*aValue);
             }
             else {
                 nsXULTemplateQueryProcessorRDF* processor = aResult->GetProcessor();
                 if (! processor)
                     return;
                 nsIRDFDataSource* ds = processor->GetDataSource();
                 if (! ds)
                     return;
                 nsCOMPtr<nsIRDFNode> subjectValue;
                 aResult->GetAssignment(binding->mSubjectVariable,
                                        getter_AddRefs(subjectValue));
                 if (subjectValue) {
                     nsCOMPtr<nsIRDFResource> subject = do_QueryInterface(subjectValue);
                     ds->GetTarget(subject, binding->mPredicate, true, aValue);
                     if (*aValue)
                         mValues[idx] = *aValue;
                 }
             }
         }
     }
 }
 void
 nsBindingValues::RemoveDependencies(nsIRDFResource* aSubject,
                                     nsXULTemplateResultRDF* aResult)
 {
     if (mBindings)
         mBindings->RemoveDependencies(aSubject, aResult);
 }

The Tor Browser / annotate

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

content/xul/templates/src/nsRDFBinding.cpp