Take 2, base::Bind cleanup in SimpleDatabaseSystem

webkit/support/simple_database_system.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/support/simple_database_system.h"
 
 #include "base/auto_reset.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDatabase.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "webkit/database/database_util.h"
@@ skipping 20 matching lines @@
   CHECK(temp_dir_.CreateUniqueTempDir());
   db_tracker_ =
       new DatabaseTracker(temp_dir_.path(), false, false, NULL, NULL, NULL);
   db_tracker_->AddObserver(this);
   db_thread_.Start();
   db_thread_proxy_ = db_thread_.message_loop_proxy();
 }
 
 SimpleDatabaseSystem::~SimpleDatabaseSystem() {
   base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::ThreadCleanup,
-                        &done_event));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::ThreadCleanup,
+                 base::Unretained(this), &done_event));
   done_event.Wait();
   instance_ = NULL;
 }
 
 void SimpleDatabaseSystem::databaseOpened(const WebKit::WebDatabase& database) {
   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
   string16 database_name = database.name();
   open_connections_->AddOpenConnection(origin_identifier, database_name);
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::DatabaseOpened,
-                        origin_identifier,
-                        database_name, database.displayName(),
-                        database.estimatedSize()));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::DatabaseOpened,
+                 base::Unretained(this),
+                 origin_identifier,
+                 database_name, database.displayName(),
+                 database.estimatedSize()));
 }
 
 void SimpleDatabaseSystem::databaseModified(
     const WebKit::WebDatabase& database) {
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::DatabaseModified,
-                        database.securityOrigin().databaseIdentifier(),
-                        database.name()));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::DatabaseModified,
+                 base::Unretained(this),
+                 database.securityOrigin().databaseIdentifier(),
+                 database.name()));
 }
 
 void SimpleDatabaseSystem::databaseClosed(const WebKit::WebDatabase& database) {
   string16 origin_identifier = database.securityOrigin().databaseIdentifier();
   string16 database_name = database.name();
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::DatabaseClosed,
-                        origin_identifier, database_name));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::DatabaseClosed,
+                 base::Unretained(this), origin_identifier, database_name));
 }
 
 base::PlatformFile SimpleDatabaseSystem::OpenFile(
     const string16& vfs_file_name, int desired_flags) {
   base::PlatformFile result = base::kInvalidPlatformFileValue;
   base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::VfsOpenFile,
-                        vfs_file_name, desired_flags,
-                        &result, &done_event));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::VfsOpenFile,
+                 base::Unretained(this),
+                 vfs_file_name, desired_flags,
+                 &result, &done_event));
   done_event.Wait();
   return result;
 }
 
 int SimpleDatabaseSystem::DeleteFile(
     const string16& vfs_file_name, bool sync_dir) {
   int result = SQLITE_OK;
   base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::VfsDeleteFile,
-                        vfs_file_name, sync_dir,
-                        &result, &done_event));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::VfsDeleteFile,
+                 base::Unretained(this),
+                 vfs_file_name, sync_dir,
+                 &result, &done_event));
   done_event.Wait();
   return result;
 }
 
 uint32 SimpleDatabaseSystem::GetFileAttributes(const string16& vfs_file_name) {
   uint32 result = 0;
   base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::VfsGetFileAttributes,
-                        vfs_file_name, &result, &done_event));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::VfsGetFileAttributes,
+                 base::Unretained(this), vfs_file_name, &result, &done_event));
   done_event.Wait();
   return result;
 }
 
 int64 SimpleDatabaseSystem::GetFileSize(const string16& vfs_file_name) {
   int64 result = 0;
   base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::VfsGetFileSize,
-                        vfs_file_name, &result, &done_event));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::VfsGetFileSize,
+                 base::Unretained(this), vfs_file_name, &result, &done_event));
   done_event.Wait();
   return result;
 }
 
 int64 SimpleDatabaseSystem::GetSpaceAvailable(
     const string16& origin_identifier) {
   int64 result = 0;
   base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::VfsGetSpaceAvailable,
-                        origin_identifier, &result, &done_event));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::VfsGetSpaceAvailable,
+                 base::Unretained(this), origin_identifier,
+                 &result, &done_event));
   done_event.Wait();
   return result;
 }
 
 void SimpleDatabaseSystem::ClearAllDatabases() {
   open_connections_->WaitForAllDatabasesToClose();
-  db_thread_proxy_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SimpleDatabaseSystem::ResetTracker));
+  db_thread_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&SimpleDatabaseSystem::ResetTracker, base::Unretained(this)));
 }
 
 void SimpleDatabaseSystem::SetDatabaseQuota(int64 quota) {
   if (!db_thread_proxy_->BelongsToCurrentThread()) {
-    db_thread_proxy_->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &SimpleDatabaseSystem::SetDatabaseQuota,
-                          quota));
+    db_thread_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&SimpleDatabaseSystem::SetDatabaseQuota,
+                   base::Unretained(this), quota));
     return;
   }
   quota_per_origin_ = quota;
 }
 
 void SimpleDatabaseSystem::DatabaseOpened(const string16& origin_identifier,
                                           const string16& database_name,
                                           const string16& description,
                                           int64 estimated_size) {
   DCHECK(db_thread_proxy_->BelongsToCurrentThread());
@@ skipping 124 matching lines @@
   file_util::Delete(db_tracker_->DatabaseDirectory(), true);
 }
 
 void SimpleDatabaseSystem::ThreadCleanup(base::WaitableEvent* done_event) {
   ResetTracker();
   db_tracker_->RemoveObserver(this);
   db_tracker_ = NULL;
   done_event->Signal();
 }