Begin CompletionCallback switchover.

Rename CompletionCallback to OldCompletionCallback in preparation for introducing a new CompletionCallback based on base::Callback.

Also renames other CompletionCallback types like CancelableCompletionCallback and TestCompletionCallback and CompletionCallbackImpl. All using sed with s/CompletionCallback/OldCompletionCallback/g.

BUG=98719
TEST=none

Review URL: http://codereview.chromium.org/8070013

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

chrome/browser/browsing_data_appcache_helper.cc

@@ -32,7 +32,7 @@ void BrowsingDataAppCacheHelper::StartFetching(Callback0::Type* callback) {
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   appcache_info_callback_ =
-      new net::CancelableCompletionCallback<BrowsingDataAppCacheHelper>(
+      new net::CancelableOldCompletionCallback<BrowsingDataAppCacheHelper>(
           this, &BrowsingDataAppCacheHelper::OnFetchComplete);
   appcache_service_->GetAllAppCacheInfo(info_collection_,
                                         appcache_info_callback_);

chrome/browser/browsing_data_appcache_helper.h

@@ -41,7 +41,7 @@ class BrowsingDataAppCacheHelper
 
   bool is_fetching_;
   scoped_refptr<ChromeAppCacheService> appcache_service_;
-  scoped_refptr<net::CancelableCompletionCallback<BrowsingDataAppCacheHelper> >
+  scoped_refptr<net::CancelableOldCompletionCallback<BrowsingDataAppCacheHelper> >
       appcache_info_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataAppCacheHelper);

chrome/browser/browsing_data_remover.h

@@ -228,7 +228,7 @@ class BrowsingDataRemover : public NotificationObserver,
   static bool removing_;
 
   // Used to delete data from the HTTP caches.
-  net::CompletionCallbackImpl<BrowsingDataRemover> cache_callback_;
+  net::OldCompletionCallbackImpl<BrowsingDataRemover> cache_callback_;
   CacheState next_cache_state_;
   disk_cache::Backend* cache_;
 

chrome/browser/chrome_benchmarking_message_filter.cc

@@ -18,7 +18,7 @@
 
 namespace {
 
-class ClearCacheCompletion : public net::CompletionCallback {
+class ClearCacheCompletion : public net::OldCompletionCallback {
  public:
   ClearCacheCompletion(ChromeBenchmarkingMessageFilter* filter,
                        IPC::Message* reply_msg)
@@ -82,7 +82,7 @@ class DoomEntriesHelper {
   disk_cache::Backend* backend_;
   disk_cache::Entry* entry_;
   void* iter_;
-  net::CompletionCallbackImpl<DoomEntriesHelper> callback_;
+  net::OldCompletionCallbackImpl<DoomEntriesHelper> callback_;
   ClearCacheCompletion* user_callback_;
 };
 

chrome/browser/chromeos/dbus/proxy_resolution_service_provider.cc

@@ -46,7 +46,7 @@ class ProxyResolverImpl : public ProxyResolverInterface {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, notify_task_);
     }
 
-    net::CompletionCallbackImpl<Request> completion_callback_;
+    net::OldCompletionCallbackImpl<Request> completion_callback_;
 
     std::string source_url_;  // URL being resolved.
     int result_;  // Result of proxy resolution.

chrome/browser/extensions/extension_webrequest_api.cc

@@ -318,7 +318,7 @@ struct ExtensionWebRequestEventRouter::BlockedRequest {
   const net::BoundNetLog* net_log;
 
   // The callback to call when we get a response from all event handlers.
-  net::CompletionCallback* callback;
+  net::OldCompletionCallback* callback;
 
   // If non-empty, this contains the new URL that the request will redirect to.
   // Only valid for OnBeforeRequest.
@@ -464,7 +464,7 @@ int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
-    net::CompletionCallback* callback,
+    net::OldCompletionCallback* callback,
     GURL* new_url) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (!profile)
@@ -506,7 +506,7 @@ int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
-    net::CompletionCallback* callback,
+    net::OldCompletionCallback* callback,
     net::HttpRequestHeaders* headers) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (!profile)
@@ -1282,7 +1282,7 @@ void ExtensionWebRequestEventRouter::DecrementBlockCount(
     // distinguished from a regular failure.
     if (blocked_request.callback) {
       int rv = canceled ? net::ERR_EMPTY_RESPONSE : net::OK;
-      net::CompletionCallback* callback = blocked_request.callback;
+      net::OldCompletionCallback* callback = blocked_request.callback;
       // Ensure that request is removed before callback because the callback
       // might trigger the next event.
       blocked_requests_.erase(request_id);

chrome/browser/extensions/extension_webrequest_api.h

@@ -149,7 +149,7 @@ class ExtensionWebRequestEventRouter {
   int OnBeforeRequest(void* profile,
                       ExtensionInfoMap* extension_info_map,
                       net::URLRequest* request,
-                      net::CompletionCallback* callback,
+                      net::OldCompletionCallback* callback,
                       GURL* new_url);
 
   // Dispatches the onBeforeSendHeaders event. This is fired for HTTP(s)
@@ -159,7 +159,7 @@ class ExtensionWebRequestEventRouter {
   int OnBeforeSendHeaders(void* profile,
                           ExtensionInfoMap* extension_info_map,
                           net::URLRequest* request,
-                          net::CompletionCallback* callback,
+                          net::OldCompletionCallback* callback,
                           net::HttpRequestHeaders* headers);
 
   // Dispatches the onSendHeaders event. This is fired for HTTP(s) requests

chrome/browser/net/chrome_network_delegate.cc

@@ -73,7 +73,7 @@ void ChromeNetworkDelegate::InitializeReferrersEnabled(
 
 int ChromeNetworkDelegate::OnBeforeURLRequest(
     net::URLRequest* request,
-    net::CompletionCallback* callback,
+    net::OldCompletionCallback* callback,
     GURL* new_url) {
 #if defined(ENABLE_CONFIGURATION_POLICY)
   // TODO(joaodasilva): This prevents extensions from seeing URLs that are
@@ -98,7 +98,7 @@ int ChromeNetworkDelegate::OnBeforeURLRequest(
 
 int ChromeNetworkDelegate::OnBeforeSendHeaders(
     net::URLRequest* request,
-    net::CompletionCallback* callback,
+    net::OldCompletionCallback* callback,
     net::HttpRequestHeaders* headers) {
   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeSendHeaders(
       profile_, extension_info_map_.get(), request, callback, headers);

chrome/browser/net/chrome_network_delegate.h

@@ -47,10 +47,10 @@ class ChromeNetworkDelegate : public net::NetworkDelegate {
  private:
   // NetworkDelegate methods:
   virtual int OnBeforeURLRequest(net::URLRequest* request,
-                                 net::CompletionCallback* callback,
+                                 net::OldCompletionCallback* callback,
                                  GURL* new_url) OVERRIDE;
   virtual int OnBeforeSendHeaders(net::URLRequest* request,
-                                  net::CompletionCallback* callback,
+                                  net::OldCompletionCallback* callback,
                                   net::HttpRequestHeaders* headers) OVERRIDE;
   virtual void OnSendHeaders(net::URLRequest* request,
                              const net::HttpRequestHeaders& headers) OVERRIDE;

chrome/browser/net/network_stats.cc

@@ -97,7 +97,7 @@ NetworkStats::~NetworkStats() {
 bool NetworkStats::Start(net::HostResolver* host_resolver,
                          const net::HostPortPair& server_host_port_pair,
                          uint32 bytes_to_send,
-                         net::CompletionCallback* finished_callback) {
+                         net::OldCompletionCallback* finished_callback) {
   DCHECK(bytes_to_send);   // We should have data to send.
 
   Initialize(bytes_to_send, finished_callback);
@@ -114,7 +114,7 @@ bool NetworkStats::Start(net::HostResolver* host_resolver,
 }
 
 void NetworkStats::Initialize(uint32 bytes_to_send,
-                              net::CompletionCallback* finished_callback) {
+                              net::OldCompletionCallback* finished_callback) {
   DCHECK(bytes_to_send);   // We should have data to send.
 
   load_size_ = bytes_to_send;
@@ -156,7 +156,7 @@ bool NetworkStats::ConnectComplete(int result) {
 
 void NetworkStats::DoFinishCallback(int result) {
   if (finished_callback_ != NULL) {
-    net::CompletionCallback* callback = finished_callback_;
+    net::OldCompletionCallback* callback = finished_callback_;
     finished_callback_ = NULL;
     callback->Run(result);
   }

chrome/browser/net/network_stats.h

@@ -74,7 +74,7 @@ class NetworkStats {
   bool Start(net::HostResolver* host_resolver,
              const net::HostPortPair& server,
              uint32 bytes_to_send,
-             net::CompletionCallback* callback);
+             net::OldCompletionCallback* callback);
 
  protected:
   // Constructs an NetworkStats object that collects metrics for network
@@ -86,7 +86,7 @@ class NetworkStats {
   // server. |finished_callback| is called when we are done with the test.
   // |finished_callback| is mainly useful for unittests.
   void Initialize(uint32 bytes_to_send,
-                  net::CompletionCallback* finished_callback);
+                  net::OldCompletionCallback* finished_callback);
 
   // Called after host is resolved. UDPStatsClient and TCPStatsClient implement
   // this method. They create the socket and connect to the server.
@@ -177,18 +177,18 @@ class NetworkStats {
   net::AddressList addresses_;
 
   // Callback to call when host resolution is completed.
-  net::CompletionCallbackImpl<NetworkStats> resolve_callback_;
+  net::OldCompletionCallbackImpl<NetworkStats> resolve_callback_;
 
   // Callback to call when data is read from the server.
-  net::CompletionCallbackImpl<NetworkStats> read_callback_;
+  net::OldCompletionCallbackImpl<NetworkStats> read_callback_;
 
   // Callback to call when data is sent to the server.
-  net::CompletionCallbackImpl<NetworkStats> write_callback_;
+  net::OldCompletionCallbackImpl<NetworkStats> write_callback_;
 
   // Callback to call when echo protocol is successefully finished or whenever
   // there is an error (this allows unittests to wait until echo protocol's
   // round trip is finished).
-  net::CompletionCallback* finished_callback_;
+  net::OldCompletionCallback* finished_callback_;
 
   // The time when the session was started.
   base::TimeTicks start_time_;
@@ -252,7 +252,7 @@ class TCPStatsClient : public NetworkStats {
   void OnConnectComplete(int result);
 
   // Callback to call when connect is completed.
-  net::CompletionCallbackImpl<TCPStatsClient> connect_callback_;
+  net::OldCompletionCallbackImpl<TCPStatsClient> connect_callback_;
 };
 
 // This collects the network connectivity stats for UDP and TCP for small

chrome/browser/net/network_stats_unittest.cc

@@ -34,7 +34,7 @@ class NetworkStatsTestUDP : public NetworkStatsTest {
 
  protected:
   void RunUDPEchoTest(int bytes) {
-    TestCompletionCallback cb;
+    TestOldCompletionCallback cb;
 
     scoped_ptr<net::MockHostResolver> host_resolver(
         new net::MockHostResolver());
@@ -61,7 +61,7 @@ class NetworkStatsTestTCP : public NetworkStatsTest {
 
  protected:
   void RunTCPEchoTest(int bytes) {
-    TestCompletionCallback cb;
+    TestOldCompletionCallback cb;
 
     scoped_ptr<net::MockHostResolver> host_resolver(
         new net::MockHostResolver());

chrome/browser/net/predictor.cc

@@ -110,7 +110,7 @@ class Predictor::LookupRequest {
   }
 
   // HostResolver will call us using this callback when resolution is complete.
-  net::CompletionCallbackImpl<LookupRequest> net_callback_;
+  net::OldCompletionCallbackImpl<LookupRequest> net_callback_;
 
   Predictor* predictor_;  // The predictor which started us.
 

chrome/browser/net/view_http_cache_job_factory.cc

@@ -71,7 +71,7 @@ class ViewHttpCacheJob : public net::URLRequestJob {
     std::string data_;
     int data_offset_;
     net::ViewCacheHelper cache_helper_;
-    net::CompletionCallbackImpl<Core> callback_;
+    net::OldCompletionCallbackImpl<Core> callback_;
     Callback0::Type* user_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);

chrome/browser/renderer_host/offline_resource_handler.cc

@@ -109,7 +109,7 @@ bool OfflineResourceHandler::OnWillStart(int request_id,
     AddRef();  //  Balanced with OnCanHandleOfflineComplete
     DCHECK(!appcache_completion_callback_);
     appcache_completion_callback_ =
-        new net::CancelableCompletionCallback<OfflineResourceHandler>(
+        new net::CancelableOldCompletionCallback<OfflineResourceHandler>(
             this, &OfflineResourceHandler::OnCanHandleOfflineComplete);
     appcache_service_->CanHandleMainResourceOffline(
         url, request_->first_party_for_cookies(),

chrome/browser/renderer_host/offline_resource_handler.h

@@ -79,7 +79,7 @@ class OfflineResourceHandler : public ResourceHandler,
   int deferred_request_id_;
   GURL deferred_url_;
 
-  scoped_refptr<net::CancelableCompletionCallback<OfflineResourceHandler> >
+  scoped_refptr<net::CancelableOldCompletionCallback<OfflineResourceHandler> >
       appcache_completion_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflineResourceHandler);

chrome/browser/safe_browsing/malware_details_unittest.cc

@@ -69,7 +69,7 @@ void WriteHeaders(disk_cache::Entry* entry, const std::string headers) {
       reinterpret_cast<const char*>(pickle.data())));
   int len = static_cast<int>(pickle.size());
 
-  TestCompletionCallback cb;
+  TestOldCompletionCallback cb;
   int rv = entry->WriteData(0, 0, buf, len, &cb, true);
   ASSERT_EQ(len, cb.GetResult(rv));
 }
@@ -82,14 +82,14 @@ void WriteData(disk_cache::Entry* entry, const std::string data) {
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(len));
   memcpy(buf->data(), data.data(), data.length());
 
-  TestCompletionCallback cb;
+  TestOldCompletionCallback cb;
   int rv = entry->WriteData(1, 0, buf, len, &cb, true);
   ASSERT_EQ(len, cb.GetResult(rv));
 }
 
 void WriteToEntry(disk_cache::Backend* cache, const std::string key,
                   const std::string headers, const std::string data) {
-  TestCompletionCallback cb;
+  TestOldCompletionCallback cb;
   disk_cache::Entry* entry;
   int rv = cache->CreateEntry(key, &entry, &cb);
   rv = cb.GetResult(rv);
@@ -104,7 +104,7 @@ void WriteToEntry(disk_cache::Backend* cache, const std::string key,
 }
 
 void FillCache(net::URLRequestContextGetter* context_getter) {
-  TestCompletionCallback cb;
+  TestOldCompletionCallback cb;
   disk_cache::Backend* cache;
   int rv =
       context_getter->GetURLRequestContext()->http_transaction_factory()->

content/browser/renderer_host/p2p/socket_dispatcher_host.cc

@@ -95,7 +95,7 @@ class P2PSocketDispatcherHost::DnsRequest {
 
   DoneCallback done_callback_;
 
-  net::CompletionCallbackImpl<DnsRequest> completion_callback_;
+  net::OldCompletionCallbackImpl<DnsRequest> completion_callback_;
 };
 
 P2PSocketDispatcherHost::P2PSocketDispatcherHost(

content/browser/renderer_host/p2p/socket_host_tcp.h

@@ -66,9 +66,9 @@ class CONTENT_EXPORT P2PSocketHostTcp : public P2PSocketHost {
 
   bool connected_;
 
-  net::CompletionCallbackImpl<P2PSocketHostTcp> connect_callback_;
-  net::CompletionCallbackImpl<P2PSocketHostTcp> read_callback_;
-  net::CompletionCallbackImpl<P2PSocketHostTcp> write_callback_;
+  net::OldCompletionCallbackImpl<P2PSocketHostTcp> connect_callback_;
+  net::OldCompletionCallbackImpl<P2PSocketHostTcp> read_callback_;
+  net::OldCompletionCallbackImpl<P2PSocketHostTcp> write_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(P2PSocketHostTcp);
 };

content/browser/renderer_host/p2p/socket_host_tcp_server.h

@@ -55,7 +55,7 @@ class CONTENT_EXPORT P2PSocketHostTcpServer : public P2PSocketHost {
   scoped_ptr<net::StreamSocket> accept_socket_;
   AcceptedSocketsMap accepted_sockets_;
 
-  net::CompletionCallbackImpl<P2PSocketHostTcpServer> accept_callback_;
+  net::OldCompletionCallbackImpl<P2PSocketHostTcpServer> accept_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(P2PSocketHostTcpServer);
 };

content/browser/renderer_host/p2p/socket_host_tcp_server_unittest.cc

@@ -33,7 +33,7 @@ class FakeServerSocket : public net::ServerSocket {
       DCHECK(incoming_sockets_.empty());
       accept_socket_->reset(socket);
       accept_socket_ = NULL;
-      net::CompletionCallback* cb = accept_callback_;
+      net::OldCompletionCallback* cb = accept_callback_;
       accept_callback_ = NULL;
       cb->Run(net::OK);
     } else {
@@ -54,7 +54,7 @@ class FakeServerSocket : public net::ServerSocket {
   }
 
   virtual int Accept(scoped_ptr<net::StreamSocket>* socket,
-                     net::CompletionCallback* callback) OVERRIDE {
+                     net::OldCompletionCallback* callback) OVERRIDE {
     DCHECK(socket);
     if (!incoming_sockets_.empty()) {
       socket->reset(incoming_sockets_.front());
@@ -73,7 +73,7 @@ class FakeServerSocket : public net::ServerSocket {
   net::IPEndPoint local_address_;
 
   scoped_ptr<net::StreamSocket>* accept_socket_;
-  net::CompletionCallback* accept_callback_;
+  net::OldCompletionCallback* accept_callback_;
 
   std::list<net::StreamSocket*> incoming_sockets_;
 };