Rename test callbacks for CookieStore to represent the argument type.

net/cookies/cookie_store_unittest.h

 // 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.
 
 #ifndef NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 72 matching lines @@
 
   // Helper methods for the asynchronous Cookie Store API that call the
   // asynchronous method and then pump the loop until the callback is invoked,
   // finally returning the value.
 
   std::string GetCookies(CookieStore* cs, const GURL& url) {
     DCHECK(cs);
     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,
                             const GURL& url,
                             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();
   }
 
   bool SetCookieWithServerTime(CookieStore* cs,
                                const GURL& url,
                                const std::string& cookie_line,
                                const base::Time& server_time) {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
     options.set_server_time(server_time);
     return SetCookieWithOptions(cs, url, cookie_line, options);
   }
 
   bool SetCookie(CookieStore* cs,
                  const GURL& url,
                  const std::string& cookie_line) {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
     return SetCookieWithOptions(cs, url, cookie_line, options);
   }
 
   void DeleteCookie(CookieStore* cs,
                     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());
   }
 
   int DeleteCreatedBetween(CookieStore* cs,
                             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) {
     // Runs the test thread message loop for up to |ms| milliseconds.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&MessageLoop::Quit, weak_factory_->GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(ms));
     MessageLoop::current()->Run();
     weak_factory_->InvalidateWeakPtrs();
   }
@@ skipping 743 matching lines @@
 class MultiThreadedCookieStoreTest :
     public CookieStoreTest<CookieStoreTestTraits> {
  public:
   MultiThreadedCookieStoreTest() : other_thread_("CMTthread") {}
 
   // Helper methods for calling the asynchronous CookieStore methods
   // from a different thread.
 
   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:
   void RunOnOtherThread(const base::Closure& task) {
     other_thread_.Start();
     other_thread_.message_loop()->PostTask(FROM_HERE, task);
     CookieStoreTest<CookieStoreTestTraits>::RunFor(kTimeout);
     other_thread_.Stop();
   }
 
   Thread other_thread_;
 };
 
 TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest);
 
 // TODO(ycxiao): Eventually, we will need to create a separate thread, create
 // the cookie store on that thread (or at least its store, i.e., the DB
 // thread).
 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) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   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) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     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),
       cs, this->url_google_, "A=B", options, &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteCookie) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B",
                                          options));
   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),
       cs, this->url_google_, "A", &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteSessionCookies) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_,
                                          "A=B", options));
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_,
       "B=C; expires=Mon, 18-Apr-22 22:50:13 GMT", options));
   EXPECT_EQ(1, this->DeleteSessionCookies(cs));
   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,
                            ThreadCheckGetCookies,
                            ThreadCheckGetCookiesWithOptions,
                            ThreadCheckSetCookieWithOptions,
                            ThreadCheckDeleteCookie,
                            ThreadCheckDeleteSessionCookies);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_UNITTEST_H_