Rename test callbacks for CookieStore to represent the argument type.

net/cookies/cookie_store_test_callbacks.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_TEST_CALLBACKS_H_
 #define NET_COOKIES_COOKIE_STORE_TEST_CALLBACKS_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 30 matching lines @@
  private:
   bool did_run_;
   base::Thread* run_in_thread_;
   base::MessageLoop* run_in_loop_;
   base::MessageLoop* parent_loop_;
   base::MessageLoop* loop_to_quit_;
 };
 
 // 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;
     CallbackEpilogue();
   }
 
   bool result() { return result_; }
 
  private:
   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();
   }
 };
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_TEST_CALLBACKS_H_