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.

[Randy Smith (Not in Mondays), 2011/10/11 15:58:58]

nit: LoadCallbackTask -> LoadedCallbackTask?

[Randy Smith (Not in Mondays), 2011/10/11 20:03:15]

Apologies, but I'm confused by this comment and a bit of thought hasn't gotten
me unconfused.  What's the danger in the callback task not being reference
counted?  Is it that it won't get destroyed if the callback is never run but
instead the reference (pointer if not a refcounted class) is dropped?

[erikwright (departed), 2011/10/11 20:11:12]

The instance of LoadedCallback that you would bind to is on the stack. You
cannot bind a callback to it because it won't be there when you invoke it. You
can also not make a copy on the heap and bind to that, because you will not be
able to destroy it after it is invoked.

[guohui, 2011/10/11 20:15:37]

Done.

[Randy Smith (Not in Mondays), 2011/10/13 21:36:28]

Got it.  Pity; a make_scoped_ptr() wrapper (doesn't exist) would solve this too
:-}.

+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,29 @@
   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*>())));
+  }
+}
+
 void MockPersistentCookieStore::AddCookie(
     const CookieMonster::CanonicalCookie& cookie) {
   commands_.push_back(
@@ -113,21 +149,38 @@
       !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*>())));
+  }
+}
+
 void MockSimplePersistentCookieStore::AddCookie(
     const CookieMonster::CanonicalCookie& cookie) {
   int64 creation_time = cookie.CreationDate().ToInternalValue();