base::Bind: Convert chrome_frame/.

chrome_frame/urlmon_url_request.cc

 // Copyright (c) 2011 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.
 
 #include "chrome_frame/urlmon_url_request.h"
 
 #include <urlmon.h>
 #include <wininet.h>
 
-#include "base/callback_old.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome_frame/bind_context_info.h"
 #include "chrome_frame/chrome_frame_activex_base.h"
@@ skipping 134 matching lines @@
   set_pending(true);
 
   // Request has already started and data is fetched. We will get the
   // GetBindInfo call as per contract but the return values are
   // ignored. So just set "get" as a method to make our GetBindInfo
   // implementation happy.
   method_ = "get";
   return S_OK;
 }
 
-void UrlmonUrlRequest::TerminateBind(TerminateBindCallback* callback) {
+void UrlmonUrlRequest::TerminateBind(const TerminateBindCallback& callback) {
   DCHECK_EQ(thread_, base::PlatformThread::CurrentId());
   DVLOG(1) << __FUNCTION__ << me();
   cleanup_transaction_ = false;
   if (status_.get_state() == Status::DONE) {
     // Binding is stopped. Note result could be an error.
-    callback->Run(moniker_, bind_context_, upload_data_,
-                  request_headers_.c_str());
-    delete callback;
+    callback.Run(moniker_, bind_context_, upload_data_,
+                 request_headers_.c_str());
   } else {
     // WORKING (ABORTING?). Save the callback.
     // Now we will return INET_TERMINATE_BIND from ::OnDataAvailable() and in
     // ::OnStopBinding will invoke the callback passing our moniker and
     // bind context.
-    terminate_bind_callback_.reset(callback);
+    terminate_bind_callback_ = callback;
     if (pending_data_) {
       // For downloads to work correctly, we must induce a call to
       // OnDataAvailable so that we can download INET_E_TERMINATED_BIND and
       // get IE into the correct state.
       // To accomplish this we read everything that's readily available in
       // the current stream.  Once we've reached the end of the stream we
       // should get E_PENDING back and then later we'll get that call
       // to OnDataAvailable.
       std::string data;
       base::win::ScopedComPtr<IStream> read_stream(pending_data_);
@@ skipping 172 matching lines @@
   DCHECK(status_.get_state() == Status::WORKING ||
          status_.get_state() == Status::ABORTING);
 
   Status::State state = status_.get_state();
 
   // Mark we a are done.
   status_.Done();
 
   if (result == INET_E_TERMINATED_BIND) {
     if (terminate_requested()) {
-      terminate_bind_callback_->Run(moniker_, bind_context_, upload_data_,
-                                    request_headers_.c_str());
+      terminate_bind_callback_.Run(moniker_, bind_context_, upload_data_,
+                                   request_headers_.c_str());
     } else {
       cleanup_transaction_ = true;
     }
     // We may have returned INET_E_TERMINATED_BIND from OnDataAvailable.
     result = S_OK;
   }
 
   if (state == Status::WORKING) {
     status_.set_result(result);
 
@@ skipping 629 matching lines @@
   // Non frame requests like sub resources, images, etc are handled on the
   // background thread.
   if (background_worker_thread_enabled_ &&
       !ResourceType::IsFrame(
           static_cast<ResourceType::Type>(request_info.resource_type))) {
     DLOG(INFO) << "Downloading resource type "
                << request_info.resource_type
                << " on background thread";
     background_thread_->message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &UrlmonUrlRequestManager::StartRequestHelper,
-                          request_id, request_info, &background_request_map_,
-                          &background_resource_map_lock_));
+        base::Bind(&UrlmonUrlRequestManager::StartRequestHelper,
+                   base::Unretained(this), request_id, request_info,
+                   &background_request_map_, &background_resource_map_lock_));
     return;
   }
   StartRequestHelper(request_id, request_info, &request_map_, NULL);
 }
 
 void UrlmonUrlRequestManager::StartRequestHelper(
     int request_id,
     const AutomationURLRequest& request_info,
     RequestMap* request_map,
     base::Lock* request_map_lock) {
@@ skipping 63 matching lines @@
   // network error.
   scoped_refptr<UrlmonUrlRequest> request = LookupRequest(request_id,
                                                           &request_map_);
   if (request) {
     request->Read(bytes_to_read);
   } else if (background_worker_thread_enabled_) {
     base::AutoLock lock(background_resource_map_lock_);
     request = LookupRequest(request_id, &background_request_map_);
     if (request) {
       background_thread_->message_loop()->PostTask(
-          FROM_HERE,
-          NewRunnableMethod(request.get(),
-                            &UrlmonUrlRequest::Read, bytes_to_read));
+          FROM_HERE, base::IgnoreReturn<bool>(base::Bind(
+              &UrlmonUrlRequest::Read, request.get(), bytes_to_read)));
     }
   }
   if (!request)
     DLOG(ERROR) << __FUNCTION__ << " no request found for " << request_id;
 }
 
 void UrlmonUrlRequestManager::DownloadRequestInHost(int request_id) {
   DVLOG(1) << __FUNCTION__ << " " << request_id;
   if (!IsWindow(notification_window_)) {
     NOTREACHED() << "Cannot handle download if we don't have anyone to hand it "
                     "to.";
     return;
   }
 
   scoped_refptr<UrlmonUrlRequest> request(LookupRequest(request_id,
                                                         &request_map_));
   if (request) {
     DownloadRequestInHostHelper(request);
   } else if (background_worker_thread_enabled_) {
     base::AutoLock lock(background_resource_map_lock_);
     request = LookupRequest(request_id, &background_request_map_);
     if (request) {
       background_thread_->message_loop()->PostTask(
           FROM_HERE,
-          NewRunnableMethod(
-              this,
-              &UrlmonUrlRequestManager::DownloadRequestInHostHelper,
-              request.get()));
+          base::Bind(&UrlmonUrlRequestManager::DownloadRequestInHostHelper,
+                     base::Unretained(this), request.get()));
     }
   }
   if (!request)
     DLOG(ERROR) << __FUNCTION__ << " no request found for " << request_id;
 }
 
 void UrlmonUrlRequestManager::DownloadRequestInHostHelper(
     UrlmonUrlRequest* request) {
   DCHECK(request);
-  UrlmonUrlRequest::TerminateBindCallback* callback = NewCallback(this,
-      &UrlmonUrlRequestManager::BindTerminated);
+  UrlmonUrlRequest::TerminateBindCallback callback =
+      base::Bind(&UrlmonUrlRequestManager::BindTerminated,
+                 base::Unretained(this));
   request->TerminateBind(callback);
 }
 
 void UrlmonUrlRequestManager::BindTerminated(IMoniker* moniker,
                                              IBindCtx* bind_ctx,
                                              IStream* post_data,
                                              const char* request_headers) {
   DownloadInHostParams* download_params = new DownloadInHostParams;
   download_params->bind_ctx = bind_ctx;
   download_params->moniker = moniker;
@@ skipping 65 matching lines @@
                                                           &request_map_);
   if (request) {
     request_map_.erase(request_id);
     request->Stop();
   } else if (background_worker_thread_enabled_) {
     base::AutoLock lock(background_resource_map_lock_);
     request = LookupRequest(request_id, &background_request_map_);
     if (request) {
       background_request_map_.erase(request_id);
       background_thread_->message_loop()->PostTask(
-          FROM_HERE,
-          NewRunnableMethod(request.get(), &UrlmonUrlRequest::Stop));
+          FROM_HERE, base::Bind(&UrlmonUrlRequest::Stop, request.get()));
     }
   }
   if (!request)
     DLOG(ERROR) << __FUNCTION__ << " no request found for " << request_id;
 }
 
 void UrlmonUrlRequestManager::StopAll() {
   DVLOG(1) << __FUNCTION__;
   if (stopping_)
     return;
 
   stopping_ = true;
 
   DVLOG(1) << __FUNCTION__ << " stopping " << request_map_.size()
            << " requests";
 
   StopAllRequestsHelper(&request_map_, NULL);
 
   if (background_worker_thread_enabled_) {
     DCHECK(background_thread_.get());
     background_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(
-            this, &UrlmonUrlRequestManager::StopAllRequestsHelper,
-            &background_request_map_, &background_resource_map_lock_));
+        FROM_HERE, base::Bind(&UrlmonUrlRequestManager::StopAllRequestsHelper,
+                              base::Unretained(this), &background_request_map_,
+                              &background_resource_map_lock_));
     background_thread_->Stop();
     background_thread_.reset();
   }
 }
 
 void UrlmonUrlRequestManager::StopAllRequestsHelper(
     RequestMap* request_map,
     base::Lock* request_map_lock) {
   DCHECK(request_map);
 
@@ skipping 143 matching lines @@
 }
 
 void UrlmonUrlRequestManager::ResourceFetcherThread::Init() {
   CoInitialize(NULL);
 }
 
 void UrlmonUrlRequestManager::ResourceFetcherThread::CleanUp() {
   CoUninitialize();
 }