Split initial load of cookies by domains

net/base/cookie_monster.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_BASE_COOKIE_MONSTER_H_
 #define NET_BASE_COOKIE_MONSTER_H_
 #pragma once
 
 #include <map>
 #include <queue>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
@@ skipping 419 matching lines @@
       initialized_ = true;
     }
   }
 
   // Initializes the backing store and reads existing cookies from it.
   // Should only be called by InitIfNecessary().
   void InitStore();
 
   // Stores cookies loaded from the backing store and invokes any deferred
   // calls. |beginning_time| should be the moment PersistentCookieStore::Load
   // was invoked and is used for reporting histogram_time_load_.

[erikwright (departed), 2011/09/15 20:56:27]

Add a note that the cookie list received here, combined with each of the cookie
lists received in OnKeyLoaded, forms the complete cookie database without any
duplicates.

[erikwright (departed), 2011/09/15 21:01:56]

Actually, add this note to PersistentCookieStore::Load and simply say here, "See
PersistentCookieStore::Load for details on the contents of cookies."

[guohui, 2011/09/16 18:21:09]

Comments added to SQLitePersistentCookieStore::Backend::NotifyOnIOThread, since
it is the only method that returns cookies to IO thread.

On 2011/09/15 21:01:56, erikwright wrote:
Done.

   void OnLoaded(base::TimeTicks beginning_time,
                 const std::vector<CanonicalCookie*>& cookies);
 
+  // Stores cookies loaded from the backing store and invokes deferred callback.
+  // Called when all cookies for the domain key(eTLD+1) has been loaded from DB.

[erikwright (departed), 2011/09/15 20:56:27]

Add a note that cookies contains a superset of the cookies for the specified
domain key.

[erikwright (departed), 2011/09/15 21:01:56]

In fact, it should say that it "normally" contains a superset of the cookies for
the specified domain, unless OnLoaded has already been invoked for all cookies.

Also, add this note to PersistentCookieStore::LoadCookiesForKey and simply say
here, "See PersistentCookieStore::LoadCookiesForKey for details on the contents
of cookies."

[guohui, 2011/09/16 18:21:09]

Done.

+  void CookieMonster::OnKeyLoaded(
+    const base::Closure& request_task, const std::string& key,
+    const std::vector<CanonicalCookie*>& cookies);
+
   // Stores the loaded cookies.
   void StoreLoadedCookies(const std::vector<CanonicalCookie*>& cookies);
 
   // Invokes deferred calls.
   void InvokeQueue();
 
   // Checks that |cookies_| matches our invariants, and tries to repair any
   // inconsistencies. (In other words, it does not have duplicate cookies).
   void EnsureCookiesMapIsValid();
 
@@ skipping 95 matching lines @@
   void RecordPeriodicStats(const base::Time& current_time);
 
   // Initialize the above variables; should only be called from
   // the constructor.
   void InitializeHistograms();
 
   // The resolution of our time isn't enough, so we do something
   // ugly and increment when we've seen the same time twice.
   base::Time CurrentTime();
 
   // Run the cookie request task if cookie loaded, otherwise added the task

[erikwright (departed), 2011/09/15 20:56:27]

Correct to:

Runs the task if, or defers the task until, the full cookie database is loaded.

[guohui, 2011/09/16 18:21:09]

Done.

   // to task queue.
   void DoCookieTask(const scoped_refptr<CookieMonsterTask>& task_item);
 
+  // Run the cookie request task for a specific URL

[erikwright (departed), 2011/09/15 20:56:27]

Correct to:

Runs the task if, or defers the task until, the cookies for the given URL are
loaded.

[guohui, 2011/09/16 18:21:09]

Done.

+  void DoCookieTask(const scoped_refptr<CookieMonsterTask>& task_item,
+    const GURL& url);
+
   // Histogram variables; see CookieMonster::InitializeHistograms() in
   // cookie_monster.cc for details.
   base::Histogram* histogram_expiration_duration_minutes_;
   base::Histogram* histogram_between_access_interval_minutes_;
   base::Histogram* histogram_evicted_last_access_minutes_;
   base::Histogram* histogram_count_;
   base::Histogram* histogram_domain_count_;
   base::Histogram* histogram_etldp1_count_;
   base::Histogram* histogram_domain_per_etldp1_count_;
   base::Histogram* histogram_number_duplicate_db_cookies_;
   base::Histogram* histogram_cookie_deletion_cause_;
   base::Histogram* histogram_time_get_;
   base::Histogram* histogram_time_mac_;
   base::Histogram* histogram_time_load_;
 
   CookieMap cookies_;
 
   // Indicates whether the cookie store has been initialized. This happens
   // lazily in InitStoreIfNecessary().
   bool initialized_;
 
   // Indicates whether loading from the backend store is completed and
   // calls may be immediately processed.
   bool loaded_;
 
+  // List of domain keys that have been loaded from DB
+  std::set<std::string> keys_loaded_;
+
   // Queues calls to CookieMonster until loading from the backend store is
   // completed.
   std::queue<scoped_refptr<CookieMonsterTask> > queue_;
 
   // Indicates whether this cookie monster uses the new effective domain
   // key scheme or not.
   ExpiryAndKeyScheme expiry_and_key_scheme_;
 
   scoped_refptr<PersistentCookieStore> store_;
 
@@ skipping 303 matching lines @@
 class CookieMonster::PersistentCookieStore
     : public RefcountedPersistentCookieStore {
  public:
   virtual ~PersistentCookieStore() {}
 
   typedef base::Callback<void(const std::vector<
       CookieMonster::CanonicalCookie*>&)> LoadedCallback;
 
   // Initializes the store and retrieves the existing cookies. This will be
   // called only once at startup.
   virtual bool Load(const LoadedCallback& loaded_callback) = 0;

[erikwright (departed), 2011/09/15 20:56:27]

Make these two methods void and declare that they will always call their
callbacks.

[guohui, 2011/09/16 18:21:09]

Done.

 
+  // Load all cookies for a domain key(eTLD+1)
+  virtual bool LoadCookiesForKey(const std::string& key,
+    const LoadedCallback& loaded_callback) = 0;
+
   virtual void AddCookie(const CanonicalCookie& cc) = 0;
   virtual void UpdateCookieAccessTime(const CanonicalCookie& cc) = 0;
   virtual void DeleteCookie(const CanonicalCookie& cc) = 0;
 
   // Sets the value of the user preference whether the persistent storage
   // must be deleted upon destruction.
   virtual void SetClearLocalStateOnExit(bool clear_local_state) = 0;
 
   // Flush the store and post the given Task when complete.
   virtual void Flush(Task* completion_task) = 0;
 
  protected:
   PersistentCookieStore() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 class CookieList : public std::vector<CookieMonster::CanonicalCookie> {
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_