base::Bind: Convert chrome/browser/profiles.

chrome/browser/profiles/profile_impl.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/browser/profiles/profile_impl.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 135 matching lines @@
 #endif
 
 enum ContextType {
   kNormalContext,
   kMediaContext
 };
 
 typedef std::list<std::pair<FilePath::StringType, int> >
     ComponentExtensionList;
 
+// Helper method needed because PostTask cannot currently take a Callback
+// function with non-void return type.
+// TODO(jhawkins): Remove once IgnoreReturn is fixed.
+void CreateDirectoryNoResult(const FilePath& path) {
+  file_util::CreateDirectory(path);
+}
+
 #if defined(FILE_MANAGER_EXTENSION)
 void AddFileManagerExtension(ComponentExtensionList* component_extensions) {
 #ifndef NDEBUG
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kFileManagerExtensionPath)) {
     FilePath filemgr_extension_path =
         command_line->GetSwitchValuePath(switches::kFileManagerExtensionPath);
     component_extensions->push_back(std::make_pair(
         filemgr_extension_path.value(),
         IDR_FILEMANAGER_MANIFEST));
@@ skipping 61 matching lines @@
       return NULL;
   }
   return new ProfileImpl(path, NULL);
 }
 
 // static
 Profile* Profile::CreateProfileAsync(const FilePath& path,
                                      Profile::Delegate* delegate) {
   DCHECK(delegate);
   // This is safe while all file operations are done on the FILE thread.
-  BrowserThread::PostTask(BrowserThread::FILE,
-                          FROM_HERE,
-                          NewRunnableFunction(&file_util::CreateDirectory,
-                                              path));
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&CreateDirectoryNoResult, path));
   // Async version.
   return new ProfileImpl(path, delegate);
 }
 
 // static
 void ProfileImpl::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kSavingBrowserHistoryDisabled,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kClearSiteDataOnExit,
@@ skipping 75 matching lines @@
   // It would be nice to use PathService for fetching this directory, but
   // the cache directory depends on the profile directory, which isn't available
   // to PathService.
   chrome::GetUserCacheDirectory(path_, &base_cache_path_);
   if (!delegate_) {
     if (!file_util::CreateDirectory(base_cache_path_))
       LOG(FATAL) << "Failed to create " << base_cache_path_.value();
   } else {
     // Async profile loading is used, so call this on the FILE thread instead.
     // It is safe since all other file operations should also be done there.
-    BrowserThread::PostTask(BrowserThread::FILE,
-                            FROM_HERE,
-                            NewRunnableFunction(&file_util::CreateDirectory,
-                                                base_cache_path_));
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&CreateDirectoryNoResult, base_cache_path_));
   }
 
 #if !defined(OS_CHROMEOS)
   // Listen for bookmark model load, to bootstrap the sync service.
   // On CrOS sync service will be initialized after sign in.
   registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
                  content::Source<Profile>(this));
 #endif
 
   PrefService* local_state = g_browser_process->local_state();
@@ skipping 279 matching lines @@
 
 ProfileImpl::~ProfileImpl() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_DESTROYED,
       content::Source<Profile>(this),
       content::NotificationService::NoDetails());
 
   if (appcache_service_ && clear_local_state_on_exit_) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(
-            appcache_service_.get(),
-            &appcache::AppCacheService::set_clear_local_state_on_exit,
-            true));
+        base::Bind(&appcache::AppCacheService::set_clear_local_state_on_exit,
+                   appcache_service_.get(), true));
   }
 
   if (webkit_context_.get())
     webkit_context_->DeleteSessionOnlyData();
 
   StopCreateSessionServiceTimer();
 
   // Remove pref observers
   pref_change_registrar_.RemoveAll();
 
   // The sync service needs to be deleted before the services it calls.
   // TODO(stevet): Make ProfileSyncService into a PKS and let the PDM take care
   // of the cleanup below.
   sync_service_.reset();
 
   ChromePluginServiceFilter::GetInstance()->UnregisterResourceContext(
       &GetResourceContext());
 
   ProfileDependencyManager::GetInstance()->DestroyProfileServices(this);
 
   if (db_tracker_) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(
-            db_tracker_.get(),
-            &webkit_database::DatabaseTracker::Shutdown));
+        base::Bind(&webkit_database::DatabaseTracker::Shutdown,
+                   db_tracker_.get()));
   }
 
   // Password store uses WebDB, shut it down before the WebDB has been shutdown.
   if (password_store_.get())
     password_store_->Shutdown();
 
   // Both HistoryService and WebDataService maintain threads for background
   // processing. Its possible each thread still has tasks on it that have
   // increased the ref count of the service. In such a situation, when we
   // decrement the refcount, it won't be 0, and the threads/databases aren't
@@ skipping 279 matching lines @@
     const Extension* extension) {
   base::Time install_time;
   if (extension->location() != Extension::COMPONENT) {
     install_time = GetExtensionService()->extension_prefs()->
         GetInstallTime(extension->id());
   }
   bool incognito_enabled =
       GetExtensionService()->IsIncognitoEnabled(extension->id());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(extension_info_map_.get(),
-                        &ExtensionInfoMap::AddExtension,
-                        make_scoped_refptr(extension),
-                        install_time, incognito_enabled));
+      base::Bind(&ExtensionInfoMap::AddExtension, extension_info_map_.get(),
+                 make_scoped_refptr(extension), install_time,
+                 incognito_enabled));
 }
 
 void ProfileImpl::UnregisterExtensionWithRequestContexts(
     const std::string& extension_id,
     const extension_misc::UnloadedExtensionReason reason) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(extension_info_map_.get(),
-                        &ExtensionInfoMap::RemoveExtension,
-                        extension_id,
-                        reason));
+      base::Bind(&ExtensionInfoMap::RemoveExtension, extension_info_map_.get(),
+                 extension_id, reason));
 }
 
 net::SSLConfigService* ProfileImpl::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
 
 HostContentSettingsMap* ProfileImpl::GetHostContentSettingsMap() {
   if (!host_content_settings_map_.get()) {
     host_content_settings_map_ = new HostContentSettingsMap(
         GetPrefs(), GetExtensionService(), false);
@@ skipping 363 matching lines @@
       GetExtensionSpecialStoragePolicy(),
       quota_manager_->proxy(),
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   webkit_context_ = new WebKitContext(
         IsOffTheRecord(), GetPath(), GetExtensionSpecialStoragePolicy(),
         clear_local_state_on_exit_, quota_manager_->proxy(),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::WEBKIT));
   appcache_service_ = new ChromeAppCacheService(quota_manager_->proxy());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(
-          appcache_service_.get(),
-          &ChromeAppCacheService::InitializeOnIOThread,
-          IsOffTheRecord()
-              ? FilePath() : GetPath().Append(chrome::kAppCacheDirname),
-          &GetResourceContext(),
-          make_scoped_refptr(GetExtensionSpecialStoragePolicy())));
+      base::Bind(&ChromeAppCacheService::InitializeOnIOThread,
+                 appcache_service_.get(),
+                 IsOffTheRecord()
+                     ? FilePath() : GetPath().Append(chrome::kAppCacheDirname),
+                 &GetResourceContext(),
+                 make_scoped_refptr(GetExtensionSpecialStoragePolicy())));
 }
 
 WebKitContext* ProfileImpl::GetWebKitContext() {
   CreateQuotaManagerAndClients();
   return webkit_context_.get();
 }
 
 void ProfileImpl::MarkAsCleanShutdown() {
   if (prefs_.get()) {
     // The session cleanly exited, set kSessionExitedCleanly appropriately.
@@ skipping 135 matching lines @@
       profile_sync_factory_->CreateProfileSyncService(cros_user));
   profile_sync_factory_->RegisterDataTypes(sync_service_.get());
   sync_service_->Initialize();
 }
 
 ChromeBlobStorageContext* ProfileImpl::GetBlobStorageContext() {
   if (!blob_storage_context_) {
     blob_storage_context_ = new ChromeBlobStorageContext();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(blob_storage_context_.get(),
-                          &ChromeBlobStorageContext::InitializeOnIOThread));
+        base::Bind(&ChromeBlobStorageContext::InitializeOnIOThread,
+                   blob_storage_context_.get()));
   }
   return blob_storage_context_;
 }
 
 ExtensionInfoMap* ProfileImpl::GetExtensionInfoMap() {
   return extension_info_map_.get();
 }
 
 ChromeURLDataManager* ProfileImpl::GetChromeURLDataManager() {
   if (!chrome_url_data_manager_.get())
@@ skipping 161 matching lines @@
   if (!home_page.is_valid())
     return GURL(chrome::kChromeUINewTabURL);
   return home_page;
 }
 
 SpellCheckProfile* ProfileImpl::GetSpellCheckProfile() {
   if (!spellcheck_profile_.get())
     spellcheck_profile_.reset(new SpellCheckProfile(path_));
   return spellcheck_profile_.get();
 }