Apply the new asynchronous CookieMonster API to extension_service_unittest.cc.

chrome/browser/extensions/extension_service_unittest.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 "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
@@ skipping 2634 matching lines @@
   UninstallExtension(good_crx, true);
 }
 
 TEST_F(ExtensionServiceTest, UninstallExtensionHelperTerminated) {
   InitializeEmptyExtensionService();
   InstallCrx(data_dir_.AppendASCII("good.crx"), true);
   TerminateExtension(good_crx);
   UninstallExtension(good_crx, true);
 }
 
+class Callback {
+ public:
+  Callback()
+      : result_(false),
+        message_loop_factory_(MessageLoop::current()) {}
+
+  void SetCookieCallback(bool result) {
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        message_loop_factory_.NewRunnableMethod(&MessageLoop::Quit),
+        10);

[Paweł Hajdan Jr., 2011/08/02 21:43:23]

Why PostDelayedTask instead of doing it immediately?

Also, this seems to be duplicating
src/chrome/browser/automation/automation_util.cc

How about ensuring we have only one copy of the code?

[ycxiao, 2011/08/02 23:00:24]

The callback of CookieMonster may be invoked immediately or delayed depending on
whether cookies are loaded in memory. The PostDelayedTask is to make sure that
the MessageLoop:quit always happens after RunAllPending(). PostTask seems also
work. But I am not confident about that.

To using the automation_util.cc we need a TabContents pointer which we don't
have it here. Otherwise we need to change the automation_util.cc. And the change
not looks trivial for me. Since we only need two callbacks here, It may not
worth to do it.

How do you think about it?

Thanks!

[Paweł Hajdan Jr., 2011/08/02 23:29:59]

Okay just get rid of PostDelayedTask.

+    result_ = result;
+  }
+
+  void GetAllCookiesCallback(const net::CookieList& list) {
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        message_loop_factory_.NewRunnableMethod(&MessageLoop::Quit),
+        10);
+    list_ = list;
+  }
+  net::CookieList list_;
+  bool result_;
+  ScopedRunnableMethodFactory<MessageLoop> message_loop_factory_;
+};
+
 // Verifies extension state is removed upon uninstall
 TEST_F(ExtensionServiceTest, ClearExtensionData) {
   InitializeEmptyExtensionService();
+  Callback callback;
 
   // Load a test extension.
   FilePath path = data_dir_;
   path = path.AppendASCII("good.crx");
   InstallCrx(path, true);
   const Extension* extension = service_->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   GURL ext_url(extension->url());
   string16 origin_id =
       webkit_database::DatabaseUtil::GetOriginIdentifier(ext_url);
 
   // Set a cookie for the extension.
   net::CookieMonster* cookie_monster =
       profile_->GetRequestContextForExtensions()->GetURLRequestContext()->
       cookie_store()->GetCookieMonster();
   ASSERT_TRUE(cookie_monster);
   net::CookieOptions options;
-  cookie_monster->SetCookieWithOptions(ext_url, "dummy=value", options);
-  net::CookieList list = cookie_monster->GetAllCookiesForURL(ext_url);
-  EXPECT_EQ(1U, list.size());
+  cookie_monster->SetCookieWithOptionsAsync(
+      ext_url, "dummy=value", options,
+      base::Bind(&Callback::SetCookieCallback,
+                 base::Unretained(&callback)));
+  loop_.RunAllPending();
+  EXPECT_TRUE(callback.result_);
+  callback.message_loop_factory_.RevokeAll();
+  cookie_monster->GetAllCookiesForURLAsync(
+      ext_url,
+      base::Bind(&Callback::GetAllCookiesCallback,
+                 base::Unretained(&callback)));
+  loop_.RunAllPending();
+  EXPECT_EQ(1U, callback.list_.size());
+  callback.message_loop_factory_.RevokeAll();
 
   // Open a database.
   webkit_database::DatabaseTracker* db_tracker = profile_->GetDatabaseTracker();
   string16 db_name = UTF8ToUTF16("db");
   string16 description = UTF8ToUTF16("db_description");
   int64 size;
   db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
   db_tracker->DatabaseClosed(origin_id, db_name);
   std::vector<webkit_database::OriginInfo> origins;
   db_tracker->GetAllOriginsInfo(&origins);
@@ skipping 16 matching lines @@
   FilePath idb_path = idb_context->GetIndexedDBFilePath(origin_id);
   EXPECT_TRUE(file_util::CreateDirectory(idb_path.DirName()));
   EXPECT_EQ(0, file_util::WriteFile(idb_path, NULL, 0));
   EXPECT_TRUE(file_util::PathExists(idb_path));
 
   // Uninstall the extension.
   service_->UninstallExtension(good_crx, false, NULL);
   loop_.RunAllPending();
 
   // Check that the cookie is gone.
-  list = cookie_monster->GetAllCookiesForURL(ext_url);
-  EXPECT_EQ(0U, list.size());
+  cookie_monster->GetAllCookiesForURLAsync(
+      ext_url,
+      base::Bind(&Callback::GetAllCookiesCallback,
+                 base::Unretained(&callback)));
+  loop_.RunAllPending();
+  EXPECT_EQ(0U, callback.list_.size());
+  callback.message_loop_factory_.RevokeAll();
 
   // The database should have vanished as well.
   origins.clear();
   db_tracker->GetAllOriginsInfo(&origins);
   EXPECT_EQ(0U, origins.size());
 
   // Check that the LSO file has been removed.
   EXPECT_FALSE(file_util::PathExists(lso_path));
 
   // Check if the indexed db has disappeared too.
@@ skipping 1057 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, true);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }