base::Bind: Cleanup in test_shell.

webkit/tools/test_shell/simple_resource_loader_bridge.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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using net::URLRequest, meaning it is a "simple"
 // version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because net::URLRequest only provides an asynchronous resource loading API,
@@ skipping 188 matching lines @@
   void DropPeer() {
     peer_ = NULL;
   }
 
   void Start(ResourceLoaderBridge::Peer* peer, RequestParams* params) {
     peer_ = peer;
     owner_loop_ = MessageLoop::current();
 
     ConvertRequestParamsForFileOverHTTPIfNeeded(params);
     // proxy over to the io thread
-    g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &RequestProxy::AsyncStart, params));
+    g_io_thread->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::AsyncStart, this, params));
   }
 
   void Cancel() {
     // proxy over to the io thread
-    g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &RequestProxy::AsyncCancel));
+    g_io_thread->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::AsyncCancel, this));
   }
 
  protected:
   friend class base::RefCountedThreadSafe<RequestProxy>;
 
   virtual ~RequestProxy() {
     // If we have a request, then we'd better be on the io thread!
     DCHECK(!request_.get() ||
            MessageLoop::current() == g_io_thread->message_loop());
   }
 
   // --------------------------------------------------------------------------
   // The following methods are called on the owner's thread in response to
   // various net::URLRequest callbacks.  The event hooks, defined below, trigger
   // these methods asynchronously.
 
   void NotifyReceivedRedirect(const GURL& new_url,
                               const ResourceResponseInfo& info) {
     bool has_new_first_party_for_cookies = false;
     GURL new_first_party_for_cookies;
     if (peer_ && peer_->OnReceivedRedirect(new_url, info,
                                            &has_new_first_party_for_cookies,
                                            &new_first_party_for_cookies)) {
-      g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &RequestProxy::AsyncFollowDeferredRedirect,
-          has_new_first_party_for_cookies, new_first_party_for_cookies));
+      g_io_thread->message_loop()->PostTask(
+          FROM_HERE,
+          base::Bind(&RequestProxy::AsyncFollowDeferredRedirect, this,
+                     has_new_first_party_for_cookies,
+                     new_first_party_for_cookies));
     } else {
       Cancel();
     }
   }
 
   void NotifyReceivedResponse(const ResourceResponseInfo& info) {
     if (peer_)
       peer_->OnReceivedResponse(info);
   }
 
   void NotifyReceivedData(int bytes_read) {
     if (!peer_)
       return;
 
     // Make a local copy of buf_, since AsyncReadData reuses it.
     scoped_array<char> buf_copy(new char[bytes_read]);
     memcpy(buf_copy.get(), buf_->data(), bytes_read);
 
     // Continue reading more data into buf_
     // Note: Doing this before notifying our peer ensures our load events get
     // dispatched in a manner consistent with DumpRenderTree (and also avoids a
     // race condition).  If the order of the next 2 functions were reversed, the
     // peer could generate new requests in reponse to the received data, which
     // when run on the io thread, could race against this function in doing
     // another InvokeLater.  See bug 769249.
-    g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &RequestProxy::AsyncReadData));
+    g_io_thread->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::AsyncReadData, this));
 
     peer_->OnReceivedData(buf_copy.get(), bytes_read, -1);
   }
 
   void NotifyDownloadedData(int bytes_read) {
     if (!peer_)
       return;
 
     // Continue reading more data, see the comment in NotifyReceivedData.
-    g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &RequestProxy::AsyncReadData));
+    g_io_thread->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::AsyncReadData, this));
 
     peer_->OnDownloadedData(bytes_read);
   }
 
   void NotifyCompletedRequest(const net::URLRequestStatus& status,
                               const std::string& security_info,
                               const base::Time& complete_time) {
     if (peer_) {
       peer_->OnCompletedRequest(status, security_info, complete_time);
       DropPeer();  // ensure no further notifications
@@ skipping 93 matching lines @@
   // --------------------------------------------------------------------------
   // The following methods are event hooks (corresponding to net::URLRequest
   // callbacks) that run on the IO thread.  They are designed to be overridden
   // by the SyncRequestProxy subclass.
 
   virtual void OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
       bool* defer_redirect) {
     *defer_redirect = true;  // See AsyncFollowDeferredRedirect
-    owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &RequestProxy::NotifyReceivedRedirect, new_url, info));
+    owner_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::NotifyReceivedRedirect, this, new_url, info));
   }
 
   virtual void OnReceivedResponse(
       const ResourceResponseInfo& info) {
-    owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &RequestProxy::NotifyReceivedResponse, info));
+    owner_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::NotifyReceivedResponse, this, info));
   }
 
   virtual void OnReceivedData(int bytes_read) {
     if (download_to_file_) {
       file_stream_.Write(buf_->data(), bytes_read, NULL);
-      owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &RequestProxy::NotifyDownloadedData, bytes_read));
+      owner_loop_->PostTask(
+          FROM_HERE,
+          base::Bind(&RequestProxy::NotifyDownloadedData, this, bytes_read));
       return;
     }
 
-    owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &RequestProxy::NotifyReceivedData, bytes_read));
+    owner_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::NotifyReceivedData, this, bytes_read));
   }
 
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
                                   const base::Time& complete_time) {
     if (download_to_file_)
       file_stream_.Close();
-    owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        this,
-        &RequestProxy::NotifyCompletedRequest,
-        status,
-        security_info,
-        complete_time));
+    owner_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&RequestProxy::NotifyCompletedRequest, this, status,
+                   security_info, complete_time));
   }
 
   // --------------------------------------------------------------------------
   // net::URLRequest::Delegate implementation:
 
   virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const GURL& new_url,
                                   bool* defer_redirect) OVERRIDE {
     DCHECK(request->status().is_success());
     ResourceResponseInfo info;
@@ skipping 101 matching lines @@
     uint64 amt_since_last = position - last_upload_position_;
     base::TimeDelta time_since_last = base::TimeTicks::Now() -
                                       last_upload_ticks_;
 
     bool is_finished = (size == position);
     bool enough_new_progress = (amt_since_last > (size /
                                                   kHalfPercentIncrements));
     bool too_much_time_passed = time_since_last > kOneSecond;
 
     if (is_finished || enough_new_progress || too_much_time_passed) {
-      owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &RequestProxy::NotifyUploadProgress, position, size));
+      owner_loop_->PostTask(
+          FROM_HERE,
+          base::Bind(&RequestProxy::NotifyUploadProgress, this, position,
+                     size));
       last_upload_ticks_ = base::TimeTicks::Now();
       last_upload_position_ = position;
     }
   }
 
   void PopulateResponseInfo(net::URLRequest* request,
                             ResourceResponseInfo* info) const {
     info->request_time = request->request_time();
     info->response_time = request->response_time();
     info->headers = request->response_headers();
@@ skipping 397 matching lines @@
                                            const GURL& first_party_for_cookies,
                                            const std::string& cookie) {
   // Proxy to IO thread to synchronize w/ network loading.
 
   if (!EnsureIOThread()) {
     NOTREACHED();
     return;
   }
 
   scoped_refptr<CookieSetter> cookie_setter(new CookieSetter());
-  g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-      cookie_setter.get(), &CookieSetter::Set, url, cookie));
+  g_io_thread->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CookieSetter::Set, cookie_setter.get(), url, cookie));
 }
 
 // static
 std::string SimpleResourceLoaderBridge::GetCookies(
     const GURL& url, const GURL& first_party_for_cookies) {
   // Proxy to IO thread to synchronize w/ network loading
 
   if (!EnsureIOThread()) {
     NOTREACHED();
     return std::string();
   }
 
   scoped_refptr<CookieGetter> getter(new CookieGetter());
 
-  g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-      getter.get(), &CookieGetter::Get, url));
+  g_io_thread->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CookieGetter::Get, getter.get(), url));
 
   return getter->GetResult();
 }
 
 // static
 bool SimpleResourceLoaderBridge::EnsureIOThread() {
   if (g_io_thread)
     return true;
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
@@ skipping 37 matching lines @@
 
 // static
 void SimpleResourceLoaderBridge::AllowFileOverHTTP(
     const std::string& file_path_template, const GURL& http_prefix) {
   DCHECK(!file_path_template.empty());
   DCHECK(http_prefix.is_valid() &&
          (http_prefix.SchemeIs("http") || http_prefix.SchemeIs("https")));
   g_file_over_http_params = new FileOverHTTPParams(file_path_template,
                                                    http_prefix);
 }