Promote CookieMonster::DeleteCanonicalCookieAsync to CookieStore.

net/cookies/cookie_monster_unittest.cc

 // Copyright (c) 2012 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/cookies/cookie_store_unittest.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 152 matching lines @@
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllCreatedBetweenForHostAsync(
         delete_begin, delete_end, url,
         base::Bind(&ResultSavingCookieCallback<int>::Run,
                    base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
-  bool DeleteCanonicalCookie(CookieMonster* cm, const CanonicalCookie& cookie) {
-    DCHECK(cm);
-    ResultSavingCookieCallback<bool> callback;
-    cm->DeleteCanonicalCookieAsync(
-        cookie, base::Bind(&ResultSavingCookieCallback<bool>::Run,
-                           base::Unretained(&callback)));
-    callback.WaitUntilDone();
-    return callback.result();
-  }
-
   // Helper for DeleteAllForHost test; repopulates CM with same layout
   // each time.
   void PopulateCmForDeleteAllForHost(scoped_refptr<CookieMonster> cm) {
     GURL url_top_level_domain_plus_1(kTopLevelDomainPlus1);
     GURL url_top_level_domain_plus_2(kTopLevelDomainPlus2);
     GURL url_top_level_domain_plus_2_secure(kTopLevelDomainPlus2Secure);
     GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
     GURL url_other(kOtherDomain);
 
     this->DeleteAll(cm.get());
@@ skipping 428 matching lines @@
   MOCK_METHOD1(Invoke, void(const CookieList& cookies));
 };
 
 class MockDeleteCallback
     : public MockCookieCallback<MockDeleteCallback,
                                 CookieMonster::DeleteCallback> {
  public:
   MOCK_METHOD1(Invoke, void(int num_deleted));
 };
 
-class MockDeleteCookieCallback
-    : public MockCookieCallback<MockDeleteCookieCallback,
-                                CookieMonster::DeleteCookieCallback> {
- public:
-  MOCK_METHOD1(Invoke, void(bool success));
-};
-
 struct CookiesInputInfo {
   const GURL url;
   const std::string name;
   const std::string value;
   const std::string domain;
   const std::string path;
   const base::Time expiration_time;
   bool secure;
   bool http_only;
   bool same_site;
@@ skipping 442 matching lines @@
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
   std::vector<CanonicalCookie*> cookies;
   CanonicalCookie cookie = BuildCanonicalCookie(
       http_www_google_.host(), "X=1; path=/", base::Time::Now());
 
-  MockDeleteCookieCallback delete_cookie_callback;
+  MockDeleteCallback delete_cookie_callback;
 
   BeginWith(DeleteCanonicalCookieAction(&cookie_monster(), cookie,
                                         &delete_cookie_callback));
 
   WaitForLoadCall();
 
-  EXPECT_CALL(delete_cookie_callback, Invoke(false))
+  EXPECT_CALL(delete_cookie_callback, Invoke(0))
       .WillOnce(DeleteCanonicalCookieAction(&cookie_monster(), cookie,
                                             &delete_cookie_callback));
   base::RunLoop loop;
-  EXPECT_CALL(delete_cookie_callback, Invoke(false))
-      .WillOnce(QuitRunLoop(&loop));
+  EXPECT_CALL(delete_cookie_callback, Invoke(0)).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteSessionCookies) {
   MockDeleteCallback delete_callback;
 
   BeginWith(DeleteSessionCookiesAction(&cookie_monster(), &delete_callback));
 
@@ skipping 140 matching lines @@
 }
 
 TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
   TestHostGarbageCollectHelper();
 }
 
 TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollection) {
   TestPriorityAwareGarbageCollectHelper();
 }
 
-TEST_F(CookieMonsterTest, TestDeleteSingleCookie) {
-  scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "C=D"));
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "E=F"));
-  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), http_www_google_.url()));
-
-  EXPECT_TRUE(
-      FindAndDeleteCookie(cm.get(), http_www_google_.url().host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
-
-  EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
-}
-
 TEST_F(CookieMonsterTest, SetCookieableSchemes) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   scoped_refptr<CookieMonster> cm_foo(new CookieMonster(NULL, NULL));
 
   // Only cm_foo should allow foo:// cookies.
   std::vector<std::string> schemes;
   schemes.push_back("foo");
   cm_foo->SetCookieableSchemes(schemes);
 
   GURL foo_url("foo://host/path");
@@ skipping 1134 matching lines @@
       const GURL& url,
       ResultSavingCookieCallback<int>* callback) {
     cm->DeleteAllCreatedBetweenForHostAsync(
         delete_begin, delete_end, url,
         base::Bind(&ResultSavingCookieCallback<int>::Run,
                    base::Unretained(callback)));
   }
 
   void DeleteCanonicalCookieTask(CookieMonster* cm,
                                  const CanonicalCookie& cookie,
-                                 ResultSavingCookieCallback<bool>* callback) {
+                                 ResultSavingCookieCallback<int>* callback) {
     cm->DeleteCanonicalCookieAsync(
-        cookie, base::Bind(&ResultSavingCookieCallback<bool>::Run,
+        cookie, base::Bind(&ResultSavingCookieCallback<int>::Run,
                            base::Unretained(callback)));
   }
 
  protected:
   void RunOnOtherThread(const base::Closure& task) {
     other_thread_.Start();
     other_thread_.task_runner()->PostTask(FROM_HERE, task);
     other_thread_.Stop();
   }
 
@@ skipping 156 matching lines @@
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   CookieList cookies = GetAllCookies(cm.get());
   CookieList::iterator it = cookies.begin();
   EXPECT_TRUE(DeleteCanonicalCookie(cm.get(), *it));
 
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
-  ResultSavingCookieCallback<bool> callback(&other_thread_);
+  ResultSavingCookieCallback<int> callback(&other_thread_);
   cookies = GetAllCookies(cm.get());
   it = cookies.begin();
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
                  base::Unretained(this), cm, *it, &callback);
   RunOnOtherThread(task);
   callback.WaitUntilDone();
-  EXPECT_TRUE(callback.result());
+  EXPECT_EQ(1, callback.result());
 }
 
 // Ensure that cookies for http, https, ws, and wss all share the same storage
 // and policies when GetAllCookiesForURLAsync is used. This test is part of
 // MultiThreadedCookieMonsterTest in order to test and use
 // GetAllCookiesForURLAsync, but it does not use any additional threads.
 TEST_F(MultiThreadedCookieMonsterTest, GetAllCookiesForURLEffectiveDomain) {
   scoped_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(
       http_www_google_.url(), kValidCookieLine, Time::Now(), CookieOptions()));
 
@@ skipping 745 matching lines @@
       monster()->AddCallbackForCookie(
           test_url_, "abc",
           base::Bind(&RecordCookieChanges, &cookies1, nullptr)));
   SetCookie(monster(), test_url_, "abc=def");
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, cookies0.size());
   EXPECT_EQ(1U, cookies0.size());
 }
 
 }  // namespace net