Update BrowsingDataRemover with the asynchronous CookieMonster API.

chrome/browser/browsing_data_remover_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/browsing_data_remover.h"
 
 #include <set>
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/testing_browser_process_test.h"
+#include "net/base/cookie_monster.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.cc"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/quota/mock_quota_manager.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 namespace {
 
 const char kTestkOrigin1[] = "http://host1:1/";
 const char kTestkOrigin2[] = "http://host2:1/";
 const char kTestkOrigin3[] = "http://host3:1/";
 
 const GURL kOrigin1(kTestkOrigin1);
 const GURL kOrigin2(kTestkOrigin2);
 const GURL kOrigin3(kTestkOrigin3);
 
 class BrowsingDataRemoverTester : public BrowsingDataRemover::Observer {
  public:
-  BrowsingDataRemoverTester() {}
+  BrowsingDataRemoverTester()
+      : start_(false),
+        already_quit_(false) {}
   virtual ~BrowsingDataRemoverTester() {}
 
   void BlockUntilNotified() {
-    MessageLoop::current()->Run();
+    if (!already_quit_) {
+      DCHECK(!start_);
+      start_ = true;
+      MessageLoop::current()->Run();
+    } else {
+      DCHECK(!start_);
+      already_quit_ = false;
+    }
   }
 
  protected:
   // BrowsingDataRemover::Observer implementation.
   virtual void OnBrowsingDataRemoverDone() {
     Notify();
   }
 
   void Notify() {
-    MessageLoop::current()->Quit();
+    if (start_) {
+      DCHECK(!already_quit_);
+      MessageLoop::current()->Quit();
+      start_ = false;
+    } else {
+      DCHECK(!already_quit_);
+      already_quit_ = true;
+    }
   }
 
  private:
+  // Helps prevent from running message_loop, if the callback invoked
+  // immediately.
+  bool start_;
+  bool already_quit_;
+
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTester);
 };
 
 // Testers -------------------------------------------------------------------
 
+class RemoveCookieTester : public BrowsingDataRemoverTester {
+ public:
+  explicit RemoveCookieTester(TestingProfile* profile)
+      : get_cookie_success_(false) {
+    profile->CreateRequestContext();
+    monster_ = profile->GetRequestContext()->GetURLRequestContext()->
+        cookie_store()->GetCookieMonster();
+  }
+
+  // Returns true, if the given cookie exists in the cookie store.
+  bool ContainsCookie() {
+    get_cookie_success_ = false;
+    monster_->GetCookiesWithOptionsAsync(
+        kOrigin1, net::CookieOptions(),
+        base::Bind(&RemoveCookieTester::GetCookieCallback,
+                   base::Unretained(this)));
+    BlockUntilNotified();
+    return get_cookie_success_;
+  }
+
+  void AddCookie() {
+    monster_->SetCookieWithOptionsAsync(
+        kOrigin1, "A=1", net::CookieOptions(),
+        base::Bind(&RemoveCookieTester::SetCookieCallback,
+                   base::Unretained(this)));
+    BlockUntilNotified();
+  }
+
+ private:
+  void GetCookieCallback(const std::string& cookies) {
+    if (cookies == "A=1") {
+      get_cookie_success_ = true;
+    } else {
+      EXPECT_EQ(cookies, "");
+      get_cookie_success_ = false;
+    }
+    Notify();
+  }
+
+  void SetCookieCallback(bool result) {
+    ASSERT_TRUE(result);
+    Notify();
+  }
+
+  bool get_cookie_success_;
+
+  net::CookieStore* monster_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveCookieTester);
+};
+
 class RemoveHistoryTester : public BrowsingDataRemoverTester {
  public:
   explicit RemoveHistoryTester(TestingProfile* profile)
       : query_url_success_(false) {
     profile->CreateHistoryService(true, false);
     history_service_ = profile->GetHistoryService(Profile::EXPLICIT_ACCESS);
   }
 
   // Returns true, if the given URL exists in the history service.
   bool HistoryContainsURL(const GURL& url) {
@@ skipping 143 matching lines @@
   BrowserThread webkit_thread_;
   BrowserThread file_thread_;
   BrowserThread io_thread_;
   scoped_ptr<TestingProfile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTest);
 };
 
 // Tests ---------------------------------------------------------------------
 
+TEST_F(BrowsingDataRemoverTest, RemoveCookieForever) {
+  scoped_ptr<RemoveCookieTester> tester(
+      new RemoveCookieTester(GetProfile()));
+
+  tester->AddCookie();
+  ASSERT_TRUE(tester->ContainsCookie());
+
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+      base::Time::Now(), BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+
+  EXPECT_FALSE(tester->ContainsCookie());
+}
+
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForever) {
   scoped_ptr<RemoveHistoryTester> tester(
       new RemoveHistoryTester(GetProfile()));
 
   tester->AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       base::Time::Now(), BrowsingDataRemover::REMOVE_HISTORY, tester.get());
 
@@ skipping 172 matching lines @@
       quota::kStorageTypeTemporary));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
       quota::kStorageTypePersistent));
   EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
       quota::kStorageTypePersistent));
 }
 
 }  // namespace