Rename test callbacks for CookieStore to represent the argument type.

These callbacks are not tightly connected to each method but are made to save
a result value of the specified type. Rename them to represent the type.

Actually, SetCookieCallback is used for testing Delete method which passes
a bool result to the done callback.

Review URL: https://chromiumcodereview.appspot.com/15380003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@201497 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 99 insertions, 90 deletions

diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index df4fa9d..0fbfe4e 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -155,11 +155,12 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                             bool http_only,
                             CookiePriority priority) {
     DCHECK(cm);
-    SetCookieCallback callback;
+    BoolResultCookieCallback callback;
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
         priority,
-        base::Bind(&SetCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(&BoolResultCookieCallback::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -167,44 +168,46 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
 
   int DeleteAll(CookieMonster*cm) {
     DCHECK(cm);
-    DeleteCallback callback;
+    IntResultCookieCallback callback;
     cm->DeleteAllAsync(
-        base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
+        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
-    return callback.num_deleted();
+    return callback.result();
   }
 
   int DeleteAllCreatedBetween(CookieMonster*cm,
                               const base::Time& delete_begin,
                               const base::Time& delete_end) {
     DCHECK(cm);
-    DeleteCallback callback;
+    IntResultCookieCallback callback;
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
+        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
-    return callback.num_deleted();
+    return callback.result();
   }
 
   int DeleteAllForHost(CookieMonster*cm,
                        const GURL& url) {
     DCHECK(cm);
-    DeleteCallback callback;
+    IntResultCookieCallback callback;
     cm->DeleteAllForHostAsync(
-        url, base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
+        url, base::Bind(&IntResultCookieCallback::Run,
+                        base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
-    return callback.num_deleted();
+    return callback.result();
   }
 
   bool DeleteCanonicalCookie(CookieMonster*cm, const CanonicalCookie& cookie) {
     DCHECK(cm);
-    SetCookieCallback callback;
+    BoolResultCookieCallback callback;
     cm->DeleteCanonicalCookieAsync(
         cookie,
-        base::Bind(&SetCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(&BoolResultCookieCallback::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -2168,7 +2171,7 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
   }
 
   void SetCookieWithDetailsTask(CookieMonster* cm, const GURL& url,
-                                SetCookieCallback* callback) {
+                                BoolResultCookieCallback* callback) {
     // Define the parameters here instead of in the calling fucntion.
     // The maximum number of parameters for Bind function is 6.
     std::string name = "A";
@@ -2182,33 +2185,33 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
         priority,
-        base::Bind(&SetCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(&BoolResultCookieCallback::Run, base::Unretained(callback)));
   }
 
   void DeleteAllCreatedBetweenTask(CookieMonster* cm,
                                    const base::Time& delete_begin,
                                    const base::Time& delete_end,
-                                   DeleteCallback* callback) {
+                                   IntResultCookieCallback* callback) {
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(&DeleteCallback::Run,
+        base::Bind(&IntResultCookieCallback::Run,
                    base::Unretained(callback)));
   }
 
   void DeleteAllForHostTask(CookieMonster* cm,
                             const GURL& url,
-                            DeleteCallback* callback) {
+                            IntResultCookieCallback* callback) {
     cm->DeleteAllForHostAsync(
         url,
-        base::Bind(&DeleteCallback::Run, base::Unretained(callback)));
+        base::Bind(&IntResultCookieCallback::Run, base::Unretained(callback)));
   }
 
   void DeleteCanonicalCookieTask(CookieMonster* cm,
                                  const CanonicalCookie& cookie,
-                                 SetCookieCallback* callback) {
+                                 BoolResultCookieCallback* callback) {
     cm->DeleteCanonicalCookieAsync(
         cookie,
-        base::Bind(&SetCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(&BoolResultCookieCallback::Run, base::Unretained(callback)));
   }
 
  protected:
@@ -2301,7 +2304,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckSetCookieWithDetails) {
       cm, url_google_foo_,
       "A", "B", std::string(), "/foo", base::Time(),
       false, false, COOKIE_PRIORITY_DEFAULT));
-  SetCookieCallback callback(&other_thread_);
+  BoolResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask,
       base::Unretained(this),
@@ -2319,7 +2322,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm, now - TimeDelta::FromDays(99),
                                        Time()));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
-  DeleteCallback callback(&other_thread_);
+  IntResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
       base::Unretained(this),
@@ -2327,7 +2330,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
       Time(), &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ(1, callback.num_deleted());
+  EXPECT_EQ(1, callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
@@ -2336,14 +2339,14 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
   EXPECT_EQ(1, DeleteAllForHost(cm, url_google_));
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
-  DeleteCallback callback(&other_thread_);
+  IntResultCookieCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllForHostTask,
       base::Unretained(this),
       cm, url_google_, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ(1, callback.num_deleted());
+  EXPECT_EQ(1, callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
@@ -2355,7 +2358,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
   EXPECT_TRUE(DeleteCanonicalCookie(cm, *it));
 
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
-  SetCookieCallback callback(&other_thread_);
+  BoolResultCookieCallback callback(&other_thread_);
   cookies = GetAllCookies(cm);
   it = cookies.begin();
   base::Closure task = base::Bind(
diff --git a/net/cookies/cookie_store_test_callbacks.cc b/net/cookies/cookie_store_test_callbacks.cc
index c0bc6cc..861a512 100644
--- a/net/cookies/cookie_store_test_callbacks.cc
+++ b/net/cookies/cookie_store_test_callbacks.cc
@@ -39,22 +39,23 @@ void CookieCallback::CallbackEpilogue() {
   loop_to_quit_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
-SetCookieCallback::SetCookieCallback() : result_(false) {}
-SetCookieCallback::SetCookieCallback(base::Thread* run_in_thread)
+BoolResultCookieCallback::BoolResultCookieCallback() : result_(false) {}
+BoolResultCookieCallback::BoolResultCookieCallback(base::Thread* run_in_thread)
     : CookieCallback(run_in_thread),
       result_(false) {}
 
-GetCookieStringCallback::GetCookieStringCallback() {}
-GetCookieStringCallback::GetCookieStringCallback(base::Thread* run_in_thread)
+StringResultCookieCallback::StringResultCookieCallback() {}
+StringResultCookieCallback::StringResultCookieCallback(
+    base::Thread* run_in_thread)
     : CookieCallback(run_in_thread) {}
 
-DeleteCallback::DeleteCallback() : num_deleted_(0) {}
-DeleteCallback::DeleteCallback(base::Thread* run_in_thread)
+IntResultCookieCallback::IntResultCookieCallback() : result_(0) {}
+IntResultCookieCallback::IntResultCookieCallback(base::Thread* run_in_thread)
     : CookieCallback(run_in_thread),
-      num_deleted_(0) {}
+      result_(0) {}
 
-DeleteCookieCallback::DeleteCookieCallback() {}
-DeleteCookieCallback::DeleteCookieCallback(base::Thread* run_in_thread)
+NoResultCookieCallback::NoResultCookieCallback() {}
+NoResultCookieCallback::NoResultCookieCallback(base::Thread* run_in_thread)
     : CookieCallback(run_in_thread) {}
 
 }  // namespace net
diff --git a/net/cookies/cookie_store_test_callbacks.h b/net/cookies/cookie_store_test_callbacks.h
index ad6f77e..c8308e1 100644
--- a/net/cookies/cookie_store_test_callbacks.h
+++ b/net/cookies/cookie_store_test_callbacks.h
@@ -48,10 +48,10 @@ class CookieCallback {
 
 // Callback implementations for the asynchronous CookieStore methods.
 
-class SetCookieCallback : public CookieCallback {
+class BoolResultCookieCallback : public CookieCallback {
  public:
-  SetCookieCallback();
-  explicit SetCookieCallback(base::Thread* run_in_thread);
+  BoolResultCookieCallback();
+  explicit BoolResultCookieCallback(base::Thread* run_in_thread);
 
   void Run(bool result) {
     result_ = result;
@@ -64,42 +64,42 @@ class SetCookieCallback : public CookieCallback {
   bool result_;
 };
 
-class GetCookieStringCallback : public CookieCallback {
+class StringResultCookieCallback : public CookieCallback {
  public:
-  GetCookieStringCallback();
-  explicit GetCookieStringCallback(base::Thread* run_in_thread);
+  StringResultCookieCallback();
+  explicit StringResultCookieCallback(base::Thread* run_in_thread);
 
-  void Run(const std::string& cookie) {
-    cookie_ = cookie;
+  void Run(const std::string& result) {
+    result_ = result;
     CallbackEpilogue();
   }
 
-  const std::string& cookie() { return cookie_; }
+  const std::string& result() { return result_; }
 
  private:
-  std::string cookie_;
+  std::string result_;
 };
 
-class DeleteCallback : public CookieCallback {
+class IntResultCookieCallback : public CookieCallback {
  public:
-  DeleteCallback();
-  explicit DeleteCallback(base::Thread* run_in_thread);
+  IntResultCookieCallback();
+  explicit IntResultCookieCallback(base::Thread* run_in_thread);
 
-  void Run(int num_deleted) {
-    num_deleted_ = num_deleted;
+  void Run(int result) {
+    result_ = result;
     CallbackEpilogue();
   }
 
-  int num_deleted() { return num_deleted_; }
+  int result() { return result_; }
 
  private:
-  int num_deleted_;
+  int result_;
 };
 
-class DeleteCookieCallback : public CookieCallback {
+class NoResultCookieCallback : public CookieCallback {
  public:
-  DeleteCookieCallback();
-  explicit DeleteCookieCallback(base::Thread* run_in_thread);
+  NoResultCookieCallback();
+  explicit NoResultCookieCallback(base::Thread* run_in_thread);
 
   void Run() {
     CallbackEpilogue();
diff --git a/net/cookies/cookie_store_unittest.h b/net/cookies/cookie_store_unittest.h
index f209ab7..bb0d42e 100644
--- a/net/cookies/cookie_store_unittest.h
+++ b/net/cookies/cookie_store_unittest.h
@@ -90,26 +90,27 @@ class CookieStoreTest : public testing::Test {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
-    GetCookieStringCallback callback;
+    StringResultCookieCallback callback;
     cs->GetCookiesWithOptionsAsync(
         url, options,
-        base::Bind(&GetCookieStringCallback::Run, base::Unretained(&callback)));
+        base::Bind(&StringResultCookieCallback::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
-    return callback.cookie();
+    return callback.result();
   }
 
   std::string GetCookiesWithOptions(CookieStore* cs,
                                     const GURL& url,
                                     const CookieOptions& options) {
     DCHECK(cs);
-    GetCookieStringCallback callback;
+    StringResultCookieCallback callback;
     cs->GetCookiesWithOptionsAsync(
-        url, options, base::Bind(&GetCookieStringCallback::Run,
+        url, options, base::Bind(&StringResultCookieCallback::Run,
                                  base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
-    return callback.cookie();
+    return callback.result();
   }
 
   bool SetCookieWithOptions(CookieStore* cs,
@@ -117,10 +118,11 @@ class CookieStoreTest : public testing::Test {
                             const std::string& cookie_line,
                             const CookieOptions& options) {
     DCHECK(cs);
-    SetCookieCallback callback;
+    BoolResultCookieCallback callback;
     cs->SetCookieWithOptionsAsync(
         url, cookie_line, options,
-        base::Bind(&SetCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(&BoolResultCookieCallback::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -150,10 +152,10 @@ class CookieStoreTest : public testing::Test {
                     const GURL& url,
                     const std::string& cookie_name) {
     DCHECK(cs);
-    DeleteCookieCallback callback;
+    NoResultCookieCallback callback;
     cs->DeleteCookieAsync(
         url, cookie_name,
-        base::Bind(&DeleteCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(&NoResultCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
   }
@@ -162,23 +164,23 @@ class CookieStoreTest : public testing::Test {
                             const base::Time& delete_begin,
                             const base::Time& delete_end) {
     DCHECK(cs);
-    DeleteCallback callback;
+    IntResultCookieCallback callback;
     cs->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
+        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
-    return callback.num_deleted();
+    return callback.result();
   }
 
   int DeleteSessionCookies(CookieStore* cs) {
     DCHECK(cs);
-    DeleteCallback callback;
+    IntResultCookieCallback callback;
     cs->DeleteSessionCookiesAsync(
-        base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
+        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
-    return callback.num_deleted();
+    return callback.result();
   }
 
   void RunFor(int ms) {
@@ -942,46 +944,49 @@ class MultiThreadedCookieStoreTest :
 
   void GetCookiesTask(CookieStore* cs,
                       const GURL& url,
-                      GetCookieStringCallback* callback) {
+                      StringResultCookieCallback* callback) {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
     cs->GetCookiesWithOptionsAsync(
         url, options,
-        base::Bind(&GetCookieStringCallback::Run, base::Unretained(callback)));
+        base::Bind(&StringResultCookieCallback::Run,
+                   base::Unretained(callback)));
   }
 
   void GetCookiesWithOptionsTask(CookieStore* cs,
                                  const GURL& url,
                                  const CookieOptions& options,
-                                 GetCookieStringCallback* callback) {
+                                 StringResultCookieCallback* callback) {
     cs->GetCookiesWithOptionsAsync(
         url, options,
-        base::Bind(&GetCookieStringCallback::Run, base::Unretained(callback)));
+        base::Bind(&StringResultCookieCallback::Run,
+                   base::Unretained(callback)));
   }
 
   void SetCookieWithOptionsTask(CookieStore* cs,
                                 const GURL& url,
                                 const std::string& cookie_line,
                                 const CookieOptions& options,
-                                SetCookieCallback* callback) {
+                                BoolResultCookieCallback* callback) {
     cs->SetCookieWithOptionsAsync(
         url, cookie_line, options,
-        base::Bind(&SetCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(&BoolResultCookieCallback::Run, base::Unretained(callback)));
   }
 
   void DeleteCookieTask(CookieStore* cs,
                         const GURL& url,
                         const std::string& cookie_name,
-                        DeleteCookieCallback* callback) {
+                        NoResultCookieCallback* callback) {
     cs->DeleteCookieAsync(
         url, cookie_name,
-        base::Bind(&DeleteCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(&NoResultCookieCallback::Run, base::Unretained(callback)));
   }
 
-    void DeleteSessionCookiesTask(CookieStore* cs, DeleteCallback* callback) {
+    void DeleteSessionCookiesTask(CookieStore* cs,
+                                  IntResultCookieCallback* callback) {
     cs->DeleteSessionCookiesAsync(
-        base::Bind(&DeleteCallback::Run, base::Unretained(callback)));
+        base::Bind(&IntResultCookieCallback::Run, base::Unretained(callback)));
   }
 
  protected:
@@ -1004,14 +1009,14 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookies) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
-  GetCookieStringCallback callback(&this->other_thread_);
+  StringResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesTask,
       base::Unretained(this),
       cs, this->url_google_, &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ("A=B", callback.cookie());
+  EXPECT_EQ("A=B", callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookiesWithOptions) {
@@ -1022,14 +1027,14 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookiesWithOptions) {
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
   this->MatchCookieLines("A=B",
       this->GetCookiesWithOptions(cs, this->url_google_, options));
-  GetCookieStringCallback callback(&this->other_thread_);
+  StringResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesWithOptionsTask,
       base::Unretained(this),
       cs, this->url_google_, options, &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ("A=B", callback.cookie());
+  EXPECT_EQ("A=B", callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckSetCookieWithOptions) {
@@ -1039,7 +1044,7 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckSetCookieWithOptions) {
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B",
                                          options));
-  SetCookieCallback callback(&this->other_thread_);
+  BoolResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::SetCookieWithOptionsTask,
       base::Unretained(this),
@@ -1059,7 +1064,7 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteCookie) {
   this->DeleteCookie(cs, this->url_google_, "A");
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B",
                                          options));
-  DeleteCookieCallback callback(&this->other_thread_);
+  NoResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteCookieTask,
       base::Unretained(this),
@@ -1081,14 +1086,14 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteSessionCookies) {
   EXPECT_EQ(0, this->DeleteSessionCookies(cs));
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_,
                                          "A=B", options));
-  DeleteCallback callback(&this->other_thread_);
+  IntResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteSessionCookiesTask,
       base::Unretained(this),
       cs, &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
-  EXPECT_EQ(1, callback.num_deleted());
+  EXPECT_EQ(1, callback.result());
 }
 
 REGISTER_TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest,