Templatize IntResultCookieCallback and BoolResultCookieCallback

StringResultCookieCallback is left un-merged since introducing
a template class with const-ref tweaking is overkilling and rather
complicating.

This change was suggested in
https://codereview.chromium.org/15380003#msg2

BUG=none

Review URL: https://codereview.chromium.org/210633004

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

4 files changed, 84 insertions, 80 deletions

diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index 0e01f28..e7fb6b0 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -157,12 +157,13 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                             bool http_only,
                             CookiePriority priority) {
     DCHECK(cm);
-    BoolResultCookieCallback callback;
+    ResultSavingCookieCallback<bool> callback;
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
         priority,
-        base::Bind(&BoolResultCookieCallback::Run,
-                   base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<bool>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -170,9 +171,11 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
 
   int DeleteAll(CookieMonster*cm) {
     DCHECK(cm);
-    IntResultCookieCallback callback;
+    ResultSavingCookieCallback<int> callback;
     cm->DeleteAllAsync(
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -182,10 +185,12 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                               const base::Time& delete_begin,
                               const base::Time& delete_end) {
     DCHECK(cm);
-    IntResultCookieCallback callback;
+    ResultSavingCookieCallback<int> callback;
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -196,10 +201,12 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
                                      const base::Time delete_end,
                                      const GURL& url) {
     DCHECK(cm);
-    IntResultCookieCallback callback;
+    ResultSavingCookieCallback<int> callback;
     cm->DeleteAllCreatedBetweenForHostAsync(
         delete_begin, delete_end, url,
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -208,9 +215,9 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
   int DeleteAllForHost(CookieMonster* cm,
                        const GURL& url) {
     DCHECK(cm);
-    IntResultCookieCallback callback;
+    ResultSavingCookieCallback<int> callback;
     cm->DeleteAllForHostAsync(
-        url, base::Bind(&IntResultCookieCallback::Run,
+        url, base::Bind(&ResultSavingCookieCallback<int>::Run,
                         base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
@@ -219,10 +226,10 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
 
   bool DeleteCanonicalCookie(CookieMonster* cm, const CanonicalCookie& cookie) {
     DCHECK(cm);
-    BoolResultCookieCallback callback;
+    ResultSavingCookieCallback<bool> callback;
     cm->DeleteCanonicalCookieAsync(
         cookie,
-        base::Bind(&BoolResultCookieCallback::Run,
+        base::Bind(&ResultSavingCookieCallback<bool>::Run,
                    base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
@@ -2336,7 +2343,7 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
   }
 
   void SetCookieWithDetailsTask(CookieMonster* cm, const GURL& url,
-                                BoolResultCookieCallback* callback) {
+                                ResultSavingCookieCallback<bool>* 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";
@@ -2350,43 +2357,51 @@ class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
         priority,
-        base::Bind(&BoolResultCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<bool>::Run,
+            base::Unretained(callback)));
   }
 
   void DeleteAllCreatedBetweenTask(CookieMonster* cm,
                                    const base::Time& delete_begin,
                                    const base::Time& delete_end,
-                                   IntResultCookieCallback* callback) {
+                                   ResultSavingCookieCallback<int>* callback) {
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(&IntResultCookieCallback::Run,
-                   base::Unretained(callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run, base::Unretained(callback)));
   }
 
   void DeleteAllForHostTask(CookieMonster* cm,
                             const GURL& url,
-                            IntResultCookieCallback* callback) {
+                            ResultSavingCookieCallback<int>* callback) {
     cm->DeleteAllForHostAsync(
         url,
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run, base::Unretained(callback)));
   }
 
-  void DeleteAllCreatedBetweenForHostTask(CookieMonster* cm,
-                                          const base::Time delete_begin,
-                                          const base::Time delete_end,
-                                          const GURL& url,
-                                          IntResultCookieCallback* callback) {
+  void DeleteAllCreatedBetweenForHostTask(
+      CookieMonster* cm,
+      const base::Time delete_begin,
+      const base::Time delete_end,
+      const GURL& url,
+      ResultSavingCookieCallback<int>* callback) {
     cm->DeleteAllCreatedBetweenForHostAsync(
         delete_begin, delete_end, url,
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(callback)));
   }
 
   void DeleteCanonicalCookieTask(CookieMonster* cm,
                                  const CanonicalCookie& cookie,
-                                 BoolResultCookieCallback* callback) {
+                                 ResultSavingCookieCallback<bool>* callback) {
     cm->DeleteCanonicalCookieAsync(
         cookie,
-        base::Bind(&BoolResultCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<bool>::Run,
+            base::Unretained(callback)));
   }
 
  protected:
@@ -2485,7 +2500,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckSetCookieWithDetails) {
                                    false,
                                    false,
                                    COOKIE_PRIORITY_DEFAULT));
-  BoolResultCookieCallback callback(&other_thread_);
+  ResultSavingCookieCallback<bool> callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask,
       base::Unretained(this),
@@ -2504,7 +2519,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
       1,
       DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99), Time()));
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
-  IntResultCookieCallback callback(&other_thread_);
+  ResultSavingCookieCallback<int> callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
       base::Unretained(this),
@@ -2521,7 +2536,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
   EXPECT_EQ(1, DeleteAllForHost(cm.get(), url_google_));
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
-  IntResultCookieCallback callback(&other_thread_);
+  ResultSavingCookieCallback<int> callback(&other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteAllForHostTask,
       base::Unretained(this),
@@ -2562,7 +2577,7 @@ TEST_F(MultiThreadedCookieMonsterTest,
           cm.get(), ago3, Time::Max(), url_google_));
 
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
-  IntResultCookieCallback callback(&other_thread_);
+  ResultSavingCookieCallback<int> callback(&other_thread_);
 
   // 2. Second set of deletions.
   base::Closure task = base::Bind(
@@ -2584,7 +2599,7 @@ TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
   EXPECT_TRUE(DeleteCanonicalCookie(cm.get(), *it));
 
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
-  BoolResultCookieCallback callback(&other_thread_);
+  ResultSavingCookieCallback<bool> callback(&other_thread_);
   cookies = GetAllCookies(cm.get());
   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 8d09f9e..8ba1c94 100644
--- a/net/cookies/cookie_store_test_callbacks.cc
+++ b/net/cookies/cookie_store_test_callbacks.cc
@@ -39,21 +39,11 @@ void CookieCallback::CallbackEpilogue() {
   loop_to_quit_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
-BoolResultCookieCallback::BoolResultCookieCallback() : result_(false) {}
-BoolResultCookieCallback::BoolResultCookieCallback(base::Thread* run_in_thread)
-    : CookieCallback(run_in_thread),
-      result_(false) {}
-
 StringResultCookieCallback::StringResultCookieCallback() {}
 StringResultCookieCallback::StringResultCookieCallback(
     base::Thread* run_in_thread)
     : CookieCallback(run_in_thread) {}
 
-IntResultCookieCallback::IntResultCookieCallback() : result_(0) {}
-IntResultCookieCallback::IntResultCookieCallback(base::Thread* run_in_thread)
-    : CookieCallback(run_in_thread),
-      result_(0) {}
-
 NoResultCookieCallback::NoResultCookieCallback() {}
 NoResultCookieCallback::NoResultCookieCallback(base::Thread* run_in_thread)
     : CookieCallback(run_in_thread) {}
diff --git a/net/cookies/cookie_store_test_callbacks.h b/net/cookies/cookie_store_test_callbacks.h
index c8308e1..eccdf1b 100644
--- a/net/cookies/cookie_store_test_callbacks.h
+++ b/net/cookies/cookie_store_test_callbacks.h
@@ -48,20 +48,24 @@ class CookieCallback {
 
 // Callback implementations for the asynchronous CookieStore methods.
 
-class BoolResultCookieCallback : public CookieCallback {
+template <typename T>
+class ResultSavingCookieCallback : public CookieCallback {
  public:
-  BoolResultCookieCallback();
-  explicit BoolResultCookieCallback(base::Thread* run_in_thread);
+  ResultSavingCookieCallback() {
+  }
+  explicit ResultSavingCookieCallback(base::Thread* run_in_thread)
+      : CookieCallback(run_in_thread) {
+  }
 
-  void Run(bool result) {
+  void Run(T result) {
     result_ = result;
     CallbackEpilogue();
   }
 
-  bool result() { return result_; }
+  const T& result() { return result_; }
 
  private:
-  bool result_;
+  T result_;
 };
 
 class StringResultCookieCallback : public CookieCallback {
@@ -80,22 +84,6 @@ class StringResultCookieCallback : public CookieCallback {
   std::string result_;
 };
 
-class IntResultCookieCallback : public CookieCallback {
- public:
-  IntResultCookieCallback();
-  explicit IntResultCookieCallback(base::Thread* run_in_thread);
-
-  void Run(int result) {
-    result_ = result;
-    CallbackEpilogue();
-  }
-
-  int result() { return result_; }
-
- private:
-  int result_;
-};
-
 class NoResultCookieCallback : public CookieCallback {
  public:
   NoResultCookieCallback();
diff --git a/net/cookies/cookie_store_unittest.h b/net/cookies/cookie_store_unittest.h
index 20854b3..f0fcd71 100644
--- a/net/cookies/cookie_store_unittest.h
+++ b/net/cookies/cookie_store_unittest.h
@@ -118,11 +118,12 @@ class CookieStoreTest : public testing::Test {
                             const std::string& cookie_line,
                             const CookieOptions& options) {
     DCHECK(cs);
-    BoolResultCookieCallback callback;
+    ResultSavingCookieCallback<bool> callback;
     cs->SetCookieWithOptionsAsync(
         url, cookie_line, options,
-        base::Bind(&BoolResultCookieCallback::Run,
-                   base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<bool>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -164,10 +165,12 @@ class CookieStoreTest : public testing::Test {
                             const base::Time& delete_begin,
                             const base::Time& delete_end) {
     DCHECK(cs);
-    IntResultCookieCallback callback;
+    ResultSavingCookieCallback<int> callback;
     cs->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -178,10 +181,12 @@ class CookieStoreTest : public testing::Test {
                                      const base::Time delete_end,
                                      const GURL& url) {
     DCHECK(cs);
-    IntResultCookieCallback callback;
+    ResultSavingCookieCallback<int> callback;
     cs->DeleteAllCreatedBetweenForHostAsync(
         delete_begin, delete_end, url,
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -189,9 +194,11 @@ class CookieStoreTest : public testing::Test {
 
   int DeleteSessionCookies(CookieStore* cs) {
     DCHECK(cs);
-    IntResultCookieCallback callback;
+    ResultSavingCookieCallback<int> callback;
     cs->DeleteSessionCookiesAsync(
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(&callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
@@ -1052,10 +1059,12 @@ class MultiThreadedCookieStoreTest :
                                 const GURL& url,
                                 const std::string& cookie_line,
                                 const CookieOptions& options,
-                                BoolResultCookieCallback* callback) {
+                                ResultSavingCookieCallback<bool>* callback) {
     cs->SetCookieWithOptionsAsync(
         url, cookie_line, options,
-        base::Bind(&BoolResultCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<bool>::Run,
+            base::Unretained(callback)));
   }
 
   void DeleteCookieTask(CookieStore* cs,
@@ -1068,9 +1077,11 @@ class MultiThreadedCookieStoreTest :
   }
 
     void DeleteSessionCookiesTask(CookieStore* cs,
-                                  IntResultCookieCallback* callback) {
+                                  ResultSavingCookieCallback<int>* callback) {
     cs->DeleteSessionCookiesAsync(
-        base::Bind(&IntResultCookieCallback::Run, base::Unretained(callback)));
+        base::Bind(
+            &ResultSavingCookieCallback<int>::Run,
+            base::Unretained(callback)));
   }
 
  protected:
@@ -1128,7 +1139,7 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckSetCookieWithOptions) {
     options.set_include_httponly();
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
-  BoolResultCookieCallback callback(&this->other_thread_);
+  ResultSavingCookieCallback<bool> callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::SetCookieWithOptionsTask,
       base::Unretained(this),
@@ -1173,7 +1184,7 @@ TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteSessionCookies) {
   EXPECT_EQ(0, this->DeleteSessionCookies(cs.get()));
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
-  IntResultCookieCallback callback(&this->other_thread_);
+  ResultSavingCookieCallback<int> callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteSessionCookiesTask,
       base::Unretained(this),