base::Bind: Cleanup in test_shell.

webkit/tools/test_shell/simple_file_writer.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 "webkit/tools/test_shell/simple_file_writer.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 using fileapi::FileSystemCallbackDispatcher;
@@ skipping 21 matching lines @@
     SimpleResourceLoaderBridge::EnsureIOThread();
     io_thread_ = SimpleResourceLoaderBridge::GetIoThread();
     main_thread_ = base::MessageLoopProxy::current();
   }
 
   virtual ~IOThreadProxy() {
   }
 
   void Truncate(const GURL& path, int64 offset) {
     if (!io_thread_->BelongsToCurrentThread()) {
-      io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &IOThreadProxy::Truncate, path, offset));
+      io_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&IOThreadProxy::Truncate, this, path, offset));
       return;
     }
     DCHECK(!operation_);
     operation_ = GetNewOperation();
     operation_->Truncate(path, offset);
   }
 
   void Write(const GURL& path, const GURL& blob_url, int64 offset) {
     if (!io_thread_->BelongsToCurrentThread()) {
-      io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &IOThreadProxy::Write, path, blob_url, offset));
+      io_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&IOThreadProxy::Write, this, path, blob_url, offset));
       return;
     }
     DCHECK(request_context_);
     DCHECK(!operation_);
     operation_ = GetNewOperation();
     operation_->Write(request_context_, path, blob_url, offset);
   }
 
   void Cancel() {
     if (!io_thread_->BelongsToCurrentThread()) {
-      io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &IOThreadProxy::Cancel));
+      io_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&IOThreadProxy::Cancel, this));
       return;
     }
     if (!operation_) {
       DidFail(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
       return;
     }
     operation_->Cancel(GetNewOperation());
   }
 
  private:
@@ skipping 42 matching lines @@
 
   FileSystemOperation* GetNewOperation() {
     // The FileSystemOperation takes ownership of the CallbackDispatcher.
     return new FileSystemOperation(new CallbackDispatcher(this),
                                    io_thread_, file_system_context_.get(),
                                    NULL);
   }
 
   void DidSucceed() {
     if (!main_thread_->BelongsToCurrentThread()) {
-      main_thread_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &IOThreadProxy::DidSucceed));
+      main_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&IOThreadProxy::DidSucceed, this));
       return;
     }
     if (simple_writer_)
       simple_writer_->DidSucceed();
   }
 
   void DidFail(base::PlatformFileError error_code) {
     if (!main_thread_->BelongsToCurrentThread()) {
-      main_thread_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &IOThreadProxy::DidFail, error_code));
+      main_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&IOThreadProxy::DidFail, this, error_code));
       return;
     }
     if (simple_writer_)
       simple_writer_->DidFail(error_code);
   }
 
   void DidWrite(int64 bytes, bool complete) {
     if (!main_thread_->BelongsToCurrentThread()) {
-      main_thread_->PostTask(FROM_HERE, NewRunnableMethod(
-          this, &IOThreadProxy::DidWrite, bytes, complete));
+      main_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&IOThreadProxy::DidWrite, this, bytes, complete));
       return;
     }
     if (simple_writer_)
       simple_writer_->DidWrite(bytes, complete);
   }
 
   void ClearOperation() {
     DCHECK(io_thread_->BelongsToCurrentThread());
     operation_ = NULL;
   }
@@ skipping 27 matching lines @@
 }
 
 void SimpleFileWriter::DoWrite(
     const GURL& path, const GURL& blob_url, int64 offset) {
   io_thread_proxy_->Write(path, blob_url, offset);
 }
 
 void SimpleFileWriter::DoCancel() {
   io_thread_proxy_->Cancel();
 }