Split initial load of cookies by domains

net/base/cookie_monster_store_test.cc

 // 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.
 
 #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"
 #include "googleurl/src/gurl.h"
 #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() {}
 
 void MockPersistentCookieStore::SetLoadExpectation(
     bool return_value,
     const std::vector<CookieMonster::CanonicalCookie*>& result) {
   load_return_value_ = return_value;
   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(
       CookieStoreCommand(CookieStoreCommand::ADD, cookie));
 }
 
 void MockPersistentCookieStore::UpdateCookieAccessTime(
     const CookieMonster::CanonicalCookie& cookie) {
@@ skipping 60 matching lines @@
   std::string cookie_path = pc.Path();
 
   return CookieMonster::CanonicalCookie(
       GURL(), pc.Name(), pc.Value(), key, cookie_path,
       pc.MACKey(), pc.MACAlgorithm(),
       creation_time, creation_time, cookie_expires,
       pc.IsSecure(), pc.IsHttpOnly(),
       !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();
   EXPECT_TRUE(cookies_.find(creation_time) == cookies_.end());
   cookies_[creation_time] = cookie;
 }
 
 void MockSimplePersistentCookieStore::UpdateCookieAccessTime(
@@ skipping 44 matching lines @@
         GURL(), "a", "1", base::StringPrintf("h%05d.izzle", i), "/path",
         mac_key, mac_algorithm, creation_time, expiration_time,
         last_access_time, false, false, true);
     store->AddCookie(cc);
   }
 
   return new CookieMonster(store, NULL);
 }
 
 }  // namespace net