Split initial load of cookies by domains

net/base/cookie_monster_store_test.cc

Index: net/base/cookie_monster_store_test.cc
===================================================================
--- net/base/cookie_monster_store_test.cc	(revision 103757)
+++ net/base/cookie_monster_store_test.cc	(working copy)
@@ -4,6 +4,7 @@
 
 #include "net/base/cookie_monster_store_test.h"
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
@@ -11,9 +12,31 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
+// Wrapper class for posting a loaded callback. Since the Callback class is not
+// reference counted, we cannot post a callback to the message loop directly,
+// instead we post a LoadCallbackTask.
+class LoadedCallbackTask
+    : public base::RefCountedThreadSafe<LoadedCallbackTask> {
+ public:
+  typedef CookieMonster::PersistentCookieStore::LoadedCallback LoadedCallback;
+  LoadedCallbackTask(LoadedCallback loaded_callback,
+                     std::vector<CookieMonster::CanonicalCookie*> cookies)
+    : loaded_callback_(loaded_callback), cookies_(cookies) {}
 
+  void Run() {
+    loaded_callback_.Run(cookies_);
+  }
+
+ private:
+  LoadedCallback loaded_callback_;
+  std::vector<CookieMonster::CanonicalCookie*> cookies_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoadedCallbackTask);
+};  // Wrapper class LoadedCallbackTask
+
 MockPersistentCookieStore::MockPersistentCookieStore()
-    : load_return_value_(true) {
+    : load_return_value_(true),
+      loaded_(false) {
 }
 
 MockPersistentCookieStore::~MockPersistentCookieStore() {}
@@ -25,16 +48,30 @@
   load_result_ = result;
 }
 
-bool MockPersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
-  bool ok = load_return_value_;
+void MockPersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
   std::vector<CookieMonster::CanonicalCookie*> out_cookies;
-  if (ok) {
+  if (load_return_value_) {
     out_cookies = load_result_;
+    loaded_ = true;
   }
-  loaded_callback.Run(out_cookies);
-  return ok;
+  MessageLoop::current()->PostTask(FROM_HERE,
+    base::Bind(&LoadedCallbackTask::Run,
+               new LoadedCallbackTask(loaded_callback, out_cookies)));
 }
 
+void MockPersistentCookieStore::LoadCookiesForKey(const std::string& key,
+    const LoadedCallback& loaded_callback) {
+  if (!loaded_) {
+    Load(loaded_callback);
+  } else {
+    MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&LoadedCallbackTask::Run,
+        new LoadedCallbackTask(loaded_callback,
+          std::vector<CookieMonster::CanonicalCookie*>())));
+    loaded_ = true;

[erikwright (departed), 2011/10/04 19:55:02]

line 71 seems redundant (loaded_ must equal true here).

[guohui, 2011/10/06 15:40:00]

Done.

+  }
+}
+
 void MockPersistentCookieStore::AddCookie(
     const CookieMonster::CanonicalCookie& cookie) {
   commands_.push_back(
@@ -113,21 +150,39 @@
       !cookie_expires.is_null());
 }
 
-MockSimplePersistentCookieStore::MockSimplePersistentCookieStore() {}
+MockSimplePersistentCookieStore::MockSimplePersistentCookieStore()
+    : loaded_(false) {}
 
 MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {}
 
-bool MockSimplePersistentCookieStore::Load(
+void MockSimplePersistentCookieStore::Load(
     const LoadedCallback& loaded_callback) {
   std::vector<CookieMonster::CanonicalCookie*> out_cookies;
+
   for (CanonicalCookieMap::const_iterator it = cookies_.begin();
        it != cookies_.end(); it++)
     out_cookies.push_back(
         new CookieMonster::CanonicalCookie(it->second));
-  loaded_callback.Run(out_cookies);
-  return true;
+
+  MessageLoop::current()->PostTask(FROM_HERE,
+    base::Bind(&LoadedCallbackTask::Run,
+               new LoadedCallbackTask(loaded_callback, out_cookies)));
+  loaded_ = true;
 }
 
+void MockSimplePersistentCookieStore::LoadCookiesForKey(const std::string& key,
+    const LoadedCallback& loaded_callback) {
+  if (!loaded_) {
+    Load(loaded_callback);
+  } else {
+    MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&LoadedCallbackTask::Run,
+        new LoadedCallbackTask(loaded_callback,
+          std::vector<CookieMonster::CanonicalCookie*>())));
+    loaded_ = true;

[erikwright (departed), 2011/10/04 19:55:02]

ditto (line 182 seems redundant).

[guohui, 2011/10/06 15:40:00]

Done.

+  }
+}
+
 void MockSimplePersistentCookieStore::AddCookie(
     const CookieMonster::CanonicalCookie& cookie) {
   int64 creation_time = cookie.CreationDate().ToInternalValue();