src/pagespeed/opt/http/two_level_property_store.cc - incubator-pagespeed-debian - Git at Google

 /*
  * Copyright 2013 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 // Author: pulkitg@google.com (Pulkit Goyal)

 #include "pagespeed/opt/http/two_level_property_store.h"

 #include "base/logging.h"
 #include "pagespeed/kernel/base/abstract_mutex.h"
 #include "pagespeed/kernel/base/callback.h"
 #include "pagespeed/kernel/base/scoped_ptr.h"
 #include "pagespeed/kernel/base/string_util.h"
 #include "pagespeed/kernel/base/thread_system.h"
 #include "pagespeed/opt/http/abstract_property_store_get_callback.h"
 #include "pagespeed/opt/http/property_cache.pb.h"

 namespace net_instaweb {

 namespace {

 // This class manages the lookup across two property stores. This class ensures
 // following things:
 // - If lookup was successful and all cohorts are available in
 //   primary_property_store, then call the done_ callback without calling
 //   lookup on secondary_property_store.
 // - If lookup was not successful or some of the cohorts are not available in
 //   primary_property_store, then issue a lookup on secondary_property_store.
 // - If FastFinishLookup is called, it checks:
 //   - If primary_property_store lookup is not yet finished, then wait until
 //     primary lookup is finished and after it is finished, call the the done_
 //     callback even if all the cohort are not available and don't issue
 //     secondary lookup.
 //   - If primary_property_store lookup is finished and secondary lookup is in
 //     progress, then call FinishFastLookup on secondary property store, so
 //     that done_ callback can be called as soon as possible.
 //   - If both lookups are finished, do nothing.
 // - If DeleteWhenDone() is called, it checks:
 //   - If both lookups are done, delete itself.
 //   - If lookup is in progress, mark a bit delete_when_done_ to true, so that
 //     it deletes itself whenever lookup is finished.
 class TwoLevelPropertyStoreGetCallback
     : public AbstractPropertyStoreGetCallback {
  public:
   typedef Callback1<bool> BoolCallback;
   TwoLevelPropertyStoreGetCallback(
       const GoogleString& url,
       const GoogleString& options_signature_hash,
       const GoogleString& cache_key_suffix,
       const PropertyCache::CohortVector& cohort_list,
       PropertyPage* page,
       BoolCallback* done,
       AbstractMutex* mutex,
       PropertyStore* primary_property_store,
       PropertyStore* secondary_property_store)
       : url_(url),
         options_signature_hash_(options_signature_hash),
         cache_key_suffix_(cache_key_suffix),
         page_(page),
         done_(done),
         mutex_(mutex),
         primary_property_store_(primary_property_store),
         secondary_property_store_(secondary_property_store),
         secondary_property_store_get_callback_(NULL),
         fast_finish_lookup_called_(false),
         lookup_level_(kFirstLevelLooking),
         delete_when_done_(false),
         first_level_result_(false),
         secondary_lookup_(false) {
     for (int j = 0, n = cohort_list.size(); j < n; ++j) {
       const PropertyCache::Cohort* cohort = cohort_list[j];
       cohort_list_.push_back(cohort);
     }
   }

   virtual ~TwoLevelPropertyStoreGetCallback() {
     if (secondary_property_store_get_callback_ != NULL) {
       secondary_property_store_get_callback_->DeleteWhenDone();
     }
   }

   virtual void FastFinishLookup() {
     AbstractPropertyStoreGetCallback* secondary_property_store_get_callback =
         NULL;
     {
       ScopedMutex lock(mutex_.get());
       fast_finish_lookup_called_ = true;
       if (lookup_level_ != kSecondLevelLooking) {
         // Return without calling the done_ callback if:
         // First level lookup is in progress : We always want first level lookup
         //     to be completed.
         // Both lookup are completed: done_ callback was already called by
         //     Done() function.
         return;
       }

       DCHECK(secondary_property_store_get_callback_ != NULL);
       secondary_property_store_get_callback =
           secondary_property_store_get_callback_;
     }

     // Fast finish the lookup from secondary property store.
     secondary_property_store_get_callback->FastFinishLookup();
   }

   virtual void DeleteWhenDone() {
     {
       ScopedMutex lock(mutex_.get());
       delete_when_done_ = true;
       // We should only ever delete ourselves if lookup is done.
       if (!ShouldDeleteLocked()) {
         return;
       }
     }

     delete this;
   }

   // Called after the primary lookup is done.
   void PrimaryLookupDone(bool success) {
     bool should_delete = false;
     BoolCallback* done = NULL;
     {
       ScopedMutex lock(mutex_.get());
       first_level_result_ = success;

       // Check if it is FastFinishLookup() is called or lookup for any cohort
       // ended up in a miss.
       for (int j = 0, n = cohort_list_.size(); j < n; ++j) {
         // Collect all the cohorts which is not present after lookup in
         // primary_property_store is done.
         const PropertyCache::Cohort* cohort = cohort_list_[j];
         if (!page_->IsCohortPresent(cohort)) {
           secondary_lookup_cohort_list_.push_back(cohort);
         }
       }

       if (fast_finish_lookup_called_ || secondary_lookup_cohort_list_.empty()) {
         lookup_level_ = kDone;
         done = done_;
         done_ = NULL;

         // We should only ever delete ourselves if we've been canceled or we got
         // results for all cohorts from the first level property store.
         should_delete = ShouldDeleteLocked();
       } else {
         secondary_lookup_ = true;
         // Do not issue the secondary level lookup while holding mutex as it may
         // lead to deadlock if secondary lookup finishes in the same thread and
         // call Done which also tries to get the Mutex.
       }
       DCHECK(!(should_delete && (lookup_level_ != kDone)));
     }

     if (!secondary_lookup_) {
       // Run the done_ callback if secondary lookup is not needed and the delete
       // the callback if DeleteWhenDone is already called.
       done->Run(success);
       if (should_delete) {
         delete this;
       }
       return;
     }

     // Second level lookup will be initiated only if FastFinishLookup() is not
     // called and some cohorts are not found in first level lookup.
     IssueSecondaryGet();
   }

   void SecondaryLookupDone(bool success) {
     bool should_delete = false;
     BoolCallback* done = NULL;
     {
       ScopedMutex lock(mutex_.get());
       DCHECK(done_ != NULL);

       // Second Level lookup finished.
       lookup_level_ = kDone;
       success |= first_level_result_;
       done = done_;
       done_ = NULL;

       // We should only ever delete ourselves if all internal states are
       // updated.
       should_delete = ShouldDeleteLocked();
     }
     if (success) {
       for (int j = 0, n = secondary_lookup_cohort_list_.size(); j < n; ++j) {
         const PropertyCache::Cohort* cohort = secondary_lookup_cohort_list_[j];
         PropertyCacheValues values;
         if (page_->EncodePropertyCacheValues(cohort, &values)) {
           primary_property_store_->Put(
               url_,
               options_signature_hash_,
               cache_key_suffix_,
               cohort,
               &values,
               NULL);
         }
       }
     }

     // No class level variable is safe to use beyond this point.
     done->Run(success);
     if (should_delete) {
       delete this;
     }
   }

  private:
   // Issue lookup from secondary_primary_store.
   void IssueSecondaryGet() {
     AbstractPropertyStoreGetCallback* secondary_property_store_get_callback =
         NULL;
     secondary_property_store_->Get(
         url_,
         options_signature_hash_,
         cache_key_suffix_,
         secondary_lookup_cohort_list_,
         page_,
         NewCallback(this,
                     &TwoLevelPropertyStoreGetCallback::SecondaryLookupDone),
         &secondary_property_store_get_callback);

     bool fast_finish_lookup_called = false;
     bool should_delete = false;
     {
       ScopedMutex lock(mutex_.get());
       secondary_property_store_get_callback_ =
           secondary_property_store_get_callback;
       // lookup_level_ will be kDone if secondary lookup finishes immediately.
       if (lookup_level_ != kDone) {
         lookup_level_ = kSecondLevelLooking;
         fast_finish_lookup_called = fast_finish_lookup_called_;
       } else {
         // We'll only delete ourselves if the second level lookup finished
         // inline.
         should_delete = ShouldDeleteLocked();
       }
     }

     if (fast_finish_lookup_called) {
       // FastFinishLookup() is called before
       // secondary_property_store_get_callback is assigned.
       secondary_property_store_get_callback->FastFinishLookup();
     }

     if (should_delete) {
       delete this;
     }
   }

   // Returns true if it is safe to delete this callback, false otherwise.
   bool ShouldDeleteLocked() {
     mutex_->DCheckLocked();
     if (secondary_lookup_ &&
         secondary_property_store_get_callback_ == NULL) {
       // We've decided to issue the second lookup but haven't yet updated our
       // internal state.
       return false;
     }

     if (lookup_level_ != kDone) {
       // Lookup is not yet finished.
       return false;
     }

     if (!delete_when_done_) {
       // DeleteWhenDone() is not yet called.
       return false;
     }

     // Safe to delete the callback.
     return true;
   }

   enum LookupLevel {
     kFirstLevelLooking,   // Lookup from primary_property_store is in progress.
     kSecondLevelLooking,  // Lookup from secondary_property_store is in
                           // progress.
     kDone,                // Lookup is finished.
   };

   GoogleString url_;
   GoogleString options_signature_hash_;
   const GoogleString& cache_key_suffix_;
   PropertyCache::CohortVector cohort_list_;
   PropertyPage* page_;  // page_ becomes NULL as soon as Done() is called.
   BoolCallback* done_;
   scoped_ptr<AbstractMutex> mutex_;
   PropertyStore* primary_property_store_;
   PropertyStore* secondary_property_store_;
   AbstractPropertyStoreGetCallback* secondary_property_store_get_callback_;
   bool fast_finish_lookup_called_;
   LookupLevel lookup_level_;
   bool delete_when_done_;
   bool first_level_result_;
   bool secondary_lookup_;
   PropertyCache::CohortVector secondary_lookup_cohort_list_;
   DISALLOW_COPY_AND_ASSIGN(TwoLevelPropertyStoreGetCallback);
 };

 }  // namespace

 TwoLevelPropertyStore::TwoLevelPropertyStore(
     PropertyStore* primary_property_store,
     PropertyStore* secondary_property_store,
     ThreadSystem* thread_system)
     : primary_property_store_(primary_property_store),
       secondary_property_store_(secondary_property_store),
       thread_system_(thread_system) {
   CHECK(primary_property_store_ != NULL);
   CHECK(secondary_property_store_ != NULL);
   secondary_property_store_->set_enable_get_cancellation(true);
 }

 TwoLevelPropertyStore::~TwoLevelPropertyStore() {
 }

 void TwoLevelPropertyStore::Get(
     const GoogleString& url,
     const GoogleString& options_signature_hash,
     const GoogleString& cache_key_suffix,
     const PropertyCache::CohortVector& cohort_list,
     PropertyPage* page,
     BoolCallback* done,
     AbstractPropertyStoreGetCallback** callback) {
   TwoLevelPropertyStoreGetCallback* two_level_property_store_get_callback =
       new TwoLevelPropertyStoreGetCallback(
           url,
           options_signature_hash,
           cache_key_suffix,
           cohort_list,
           page,
           done,
           thread_system_->NewMutex(),
           primary_property_store_,
           secondary_property_store_);
   *callback = two_level_property_store_get_callback;

   AbstractPropertyStoreGetCallback* primary_property_store_get_callback = NULL;
   primary_property_store_->Get(
       url,
       options_signature_hash,
       cache_key_suffix,
       cohort_list,
       page,
       NewCallback(two_level_property_store_get_callback,
                   &TwoLevelPropertyStoreGetCallback::PrimaryLookupDone),
       &primary_property_store_get_callback);

   if (primary_property_store_get_callback != NULL) {
     // Delete the primary store get callback when it is done as it is not needed
     // any more.
     primary_property_store_get_callback->DeleteWhenDone();
   }
 }

 void TwoLevelPropertyStore::Put(
     const GoogleString& url,
     const GoogleString& options_signature_hash,
     const GoogleString& cache_key_suffix,
     const PropertyCache::Cohort* cohort,
     const PropertyCacheValues* values,
     BoolCallback* done) {
   // TODO(pulkitg): Pass actual callback instead of NULL.
   primary_property_store_->Put(
       url, options_signature_hash, cache_key_suffix, cohort, values, NULL);
   secondary_property_store_->Put(
       url, options_signature_hash, cache_key_suffix, cohort, values, NULL);
   if (done != NULL) {
     done->Run(true);
   }
 }

 GoogleString TwoLevelPropertyStore::Name() const {
   return StrCat(
       "1:", primary_property_store_->Name(),
       ",2:", secondary_property_store_->Name());
 }

 }  // namespace net_instaweb
	/*
	* Copyright 2013 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	// Author: pulkitg@google.com (Pulkit Goyal)

	#include "pagespeed/opt/http/two_level_property_store.h"

	#include "base/logging.h"
	#include "pagespeed/kernel/base/abstract_mutex.h"
	#include "pagespeed/kernel/base/callback.h"
	#include "pagespeed/kernel/base/scoped_ptr.h"
	#include "pagespeed/kernel/base/string_util.h"
	#include "pagespeed/kernel/base/thread_system.h"
	#include "pagespeed/opt/http/abstract_property_store_get_callback.h"
	#include "pagespeed/opt/http/property_cache.pb.h"

	namespace net_instaweb {

	namespace {

	// This class manages the lookup across two property stores. This class ensures
	// following things:
	// - If lookup was successful and all cohorts are available in
	// primary_property_store, then call the done_ callback without calling
	// lookup on secondary_property_store.
	// - If lookup was not successful or some of the cohorts are not available in
	// primary_property_store, then issue a lookup on secondary_property_store.
	// - If FastFinishLookup is called, it checks:
	// - If primary_property_store lookup is not yet finished, then wait until
	// primary lookup is finished and after it is finished, call the the done_
	// callback even if all the cohort are not available and don't issue
	// secondary lookup.
	// - If primary_property_store lookup is finished and secondary lookup is in
	// progress, then call FinishFastLookup on secondary property store, so
	// that done_ callback can be called as soon as possible.
	// - If both lookups are finished, do nothing.
	// - If DeleteWhenDone() is called, it checks:
	// - If both lookups are done, delete itself.
	// - If lookup is in progress, mark a bit delete_when_done_ to true, so that
	// it deletes itself whenever lookup is finished.
	class TwoLevelPropertyStoreGetCallback
	: public AbstractPropertyStoreGetCallback {
	public:
	typedef Callback1<bool> BoolCallback;
	TwoLevelPropertyStoreGetCallback(
	const GoogleString& url,
	const GoogleString& options_signature_hash,
	const GoogleString& cache_key_suffix,
	const PropertyCache::CohortVector& cohort_list,
	PropertyPage* page,
	BoolCallback* done,
	AbstractMutex* mutex,
	PropertyStore* primary_property_store,
	PropertyStore* secondary_property_store)
	: url_(url),
	options_signature_hash_(options_signature_hash),
	cache_key_suffix_(cache_key_suffix),
	page_(page),
	done_(done),
	mutex_(mutex),
	primary_property_store_(primary_property_store),
	secondary_property_store_(secondary_property_store),
	secondary_property_store_get_callback_(NULL),
	fast_finish_lookup_called_(false),
	lookup_level_(kFirstLevelLooking),
	delete_when_done_(false),
	first_level_result_(false),
	secondary_lookup_(false) {
	for (int j = 0, n = cohort_list.size(); j < n; ++j) {
	const PropertyCache::Cohort* cohort = cohort_list[j];
	cohort_list_.push_back(cohort);
	}
	}

	virtual ~TwoLevelPropertyStoreGetCallback() {
	if (secondary_property_store_get_callback_ != NULL) {
	secondary_property_store_get_callback_->DeleteWhenDone();
	}
	}

	virtual void FastFinishLookup() {
	AbstractPropertyStoreGetCallback* secondary_property_store_get_callback =
	NULL;
	{
	ScopedMutex lock(mutex_.get());
	fast_finish_lookup_called_ = true;
	if (lookup_level_ != kSecondLevelLooking) {
	// Return without calling the done_ callback if:
	// First level lookup is in progress : We always want first level lookup
	// to be completed.
	// Both lookup are completed: done_ callback was already called by
	// Done() function.
	return;
	}

	DCHECK(secondary_property_store_get_callback_ != NULL);
	secondary_property_store_get_callback =
	secondary_property_store_get_callback_;
	}

	// Fast finish the lookup from secondary property store.
	secondary_property_store_get_callback->FastFinishLookup();
	}

	virtual void DeleteWhenDone() {
	{
	ScopedMutex lock(mutex_.get());
	delete_when_done_ = true;
	// We should only ever delete ourselves if lookup is done.
	if (!ShouldDeleteLocked()) {
	return;
	}
	}

	delete this;
	}

	// Called after the primary lookup is done.
	void PrimaryLookupDone(bool success) {
	bool should_delete = false;
	BoolCallback* done = NULL;
	{
	ScopedMutex lock(mutex_.get());
	first_level_result_ = success;

	// Check if it is FastFinishLookup() is called or lookup for any cohort
	// ended up in a miss.
	for (int j = 0, n = cohort_list_.size(); j < n; ++j) {
	// Collect all the cohorts which is not present after lookup in
	// primary_property_store is done.
	const PropertyCache::Cohort* cohort = cohort_list_[j];
	if (!page_->IsCohortPresent(cohort)) {
	secondary_lookup_cohort_list_.push_back(cohort);
	}
	}

	if (fast_finish_lookup_called_ \|\| secondary_lookup_cohort_list_.empty()) {
	lookup_level_ = kDone;
	done = done_;
	done_ = NULL;

	// We should only ever delete ourselves if we've been canceled or we got
	// results for all cohorts from the first level property store.
	should_delete = ShouldDeleteLocked();
	} else {
	secondary_lookup_ = true;
	// Do not issue the secondary level lookup while holding mutex as it may
	// lead to deadlock if secondary lookup finishes in the same thread and
	// call Done which also tries to get the Mutex.
	}
	DCHECK(!(should_delete && (lookup_level_ != kDone)));
	}

	if (!secondary_lookup_) {
	// Run the done_ callback if secondary lookup is not needed and the delete
	// the callback if DeleteWhenDone is already called.
	done->Run(success);
	if (should_delete) {
	delete this;
	}
	return;
	}

	// Second level lookup will be initiated only if FastFinishLookup() is not
	// called and some cohorts are not found in first level lookup.
	IssueSecondaryGet();
	}

	void SecondaryLookupDone(bool success) {
	bool should_delete = false;
	BoolCallback* done = NULL;
	{
	ScopedMutex lock(mutex_.get());
	DCHECK(done_ != NULL);

	// Second Level lookup finished.
	lookup_level_ = kDone;
	success \|= first_level_result_;
	done = done_;
	done_ = NULL;

	// We should only ever delete ourselves if all internal states are
	// updated.
	should_delete = ShouldDeleteLocked();
	}
	if (success) {
	for (int j = 0, n = secondary_lookup_cohort_list_.size(); j < n; ++j) {
	const PropertyCache::Cohort* cohort = secondary_lookup_cohort_list_[j];
	PropertyCacheValues values;
	if (page_->EncodePropertyCacheValues(cohort, &values)) {
	primary_property_store_->Put(
	url_,
	options_signature_hash_,
	cache_key_suffix_,
	cohort,
	&values,
	NULL);
	}
	}
	}

	// No class level variable is safe to use beyond this point.
	done->Run(success);
	if (should_delete) {
	delete this;
	}
	}

	private:
	// Issue lookup from secondary_primary_store.
	void IssueSecondaryGet() {
	AbstractPropertyStoreGetCallback* secondary_property_store_get_callback =
	NULL;
	secondary_property_store_->Get(
	url_,
	options_signature_hash_,
	cache_key_suffix_,
	secondary_lookup_cohort_list_,
	page_,
	NewCallback(this,
	&TwoLevelPropertyStoreGetCallback::SecondaryLookupDone),
	&secondary_property_store_get_callback);

	bool fast_finish_lookup_called = false;
	bool should_delete = false;
	{
	ScopedMutex lock(mutex_.get());
	secondary_property_store_get_callback_ =
	secondary_property_store_get_callback;
	// lookup_level_ will be kDone if secondary lookup finishes immediately.
	if (lookup_level_ != kDone) {
	lookup_level_ = kSecondLevelLooking;
	fast_finish_lookup_called = fast_finish_lookup_called_;
	} else {
	// We'll only delete ourselves if the second level lookup finished
	// inline.
	should_delete = ShouldDeleteLocked();
	}
	}

	if (fast_finish_lookup_called) {
	// FastFinishLookup() is called before
	// secondary_property_store_get_callback is assigned.
	secondary_property_store_get_callback->FastFinishLookup();
	}

	if (should_delete) {
	delete this;
	}
	}

	// Returns true if it is safe to delete this callback, false otherwise.
	bool ShouldDeleteLocked() {
	mutex_->DCheckLocked();
	if (secondary_lookup_ &&
	secondary_property_store_get_callback_ == NULL) {
	// We've decided to issue the second lookup but haven't yet updated our
	// internal state.
	return false;
	}

	if (lookup_level_ != kDone) {
	// Lookup is not yet finished.
	return false;
	}

	if (!delete_when_done_) {
	// DeleteWhenDone() is not yet called.
	return false;
	}

	// Safe to delete the callback.
	return true;
	}

	enum LookupLevel {
	kFirstLevelLooking, // Lookup from primary_property_store is in progress.
	kSecondLevelLooking, // Lookup from secondary_property_store is in
	// progress.
	kDone, // Lookup is finished.
	};

	GoogleString url_;
	GoogleString options_signature_hash_;
	const GoogleString& cache_key_suffix_;
	PropertyCache::CohortVector cohort_list_;
	PropertyPage* page_; // page_ becomes NULL as soon as Done() is called.
	BoolCallback* done_;
	scoped_ptr<AbstractMutex> mutex_;
	PropertyStore* primary_property_store_;
	PropertyStore* secondary_property_store_;
	AbstractPropertyStoreGetCallback* secondary_property_store_get_callback_;
	bool fast_finish_lookup_called_;
	LookupLevel lookup_level_;
	bool delete_when_done_;
	bool first_level_result_;
	bool secondary_lookup_;
	PropertyCache::CohortVector secondary_lookup_cohort_list_;
	DISALLOW_COPY_AND_ASSIGN(TwoLevelPropertyStoreGetCallback);
	};

	} // namespace

	TwoLevelPropertyStore::TwoLevelPropertyStore(
	PropertyStore* primary_property_store,
	PropertyStore* secondary_property_store,
	ThreadSystem* thread_system)
	: primary_property_store_(primary_property_store),
	secondary_property_store_(secondary_property_store),
	thread_system_(thread_system) {
	CHECK(primary_property_store_ != NULL);
	CHECK(secondary_property_store_ != NULL);
	secondary_property_store_->set_enable_get_cancellation(true);
	}

	TwoLevelPropertyStore::~TwoLevelPropertyStore() {
	}

	void TwoLevelPropertyStore::Get(
	const GoogleString& url,
	const GoogleString& options_signature_hash,
	const GoogleString& cache_key_suffix,
	const PropertyCache::CohortVector& cohort_list,
	PropertyPage* page,
	BoolCallback* done,
	AbstractPropertyStoreGetCallback** callback) {
	TwoLevelPropertyStoreGetCallback* two_level_property_store_get_callback =
	new TwoLevelPropertyStoreGetCallback(
	url,
	options_signature_hash,
	cache_key_suffix,
	cohort_list,
	page,
	done,
	thread_system_->NewMutex(),
	primary_property_store_,
	secondary_property_store_);
	*callback = two_level_property_store_get_callback;

	AbstractPropertyStoreGetCallback* primary_property_store_get_callback = NULL;
	primary_property_store_->Get(
	url,
	options_signature_hash,
	cache_key_suffix,
	cohort_list,
	page,
	NewCallback(two_level_property_store_get_callback,
	&TwoLevelPropertyStoreGetCallback::PrimaryLookupDone),
	&primary_property_store_get_callback);

	if (primary_property_store_get_callback != NULL) {
	// Delete the primary store get callback when it is done as it is not needed
	// any more.
	primary_property_store_get_callback->DeleteWhenDone();
	}
	}

	void TwoLevelPropertyStore::Put(
	const GoogleString& url,
	const GoogleString& options_signature_hash,
	const GoogleString& cache_key_suffix,
	const PropertyCache::Cohort* cohort,
	const PropertyCacheValues* values,
	BoolCallback* done) {
	// TODO(pulkitg): Pass actual callback instead of NULL.
	primary_property_store_->Put(
	url, options_signature_hash, cache_key_suffix, cohort, values, NULL);
	secondary_property_store_->Put(
	url, options_signature_hash, cache_key_suffix, cohort, values, NULL);
	if (done != NULL) {
	done->Run(true);
	}
	}

	GoogleString TwoLevelPropertyStore::Name() const {
	return StrCat(
	"1:", primary_property_store_->Name(),
	",2:", secondary_property_store_->Name());
	}

	} // namespace net_instaweb