base::Bind() conversion for BrowserProcessImpl

chrome/browser/browser_process_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/browser_process_impl.h"
 
 #include <map>
 #include <set>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/background/background_mode_manager.h"
 #include "chrome/browser/browser_trial.h"
 #include "chrome/browser/chrome_browser_main.h"
 #include "chrome/browser/chrome_plugin_service_filter.h"
 #include "chrome/browser/component_updater/component_updater_configurator.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/browser/debugger/devtools_protocol_handler.h"
@@ skipping 181 matching lines @@
   // before the profiles, since if there are any still showing we will access
   // those things during teardown.
   notification_ui_manager_.reset();
 
   // FIXME - We shouldn't need this, it's because of DefaultRequestContext! :(
   // We need to kill off all URLFetchers using profile related
   // URLRequestContexts. Normally that'd be covered by deleting the Profiles,
   // but we have some URLFetchers using the DefaultRequestContext, so they need
   // to be cancelled too. Remove this when DefaultRequestContext goes away.
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          NewRunnableFunction(&content::URLFetcher::CancelAll));
+                          base::Bind(&content::URLFetcher::CancelAll));
 
   // Need to clear profiles (download managers) before the io_thread_.
   profile_manager_.reset();
 
   // Debugger must be cleaned up before IO thread and NotificationService.
   remote_debugging_server_.reset();
 
   if (devtools_legacy_handler_.get()) {
     devtools_legacy_handler_->Stop();
     devtools_legacy_handler_ = NULL;
@@ skipping 89 matching lines @@
   DCHECK_NE(0u, module_ref_count_);
   module_ref_count_--;
   if (0 == module_ref_count_) {
     CHECK(MessageLoop::current()->is_running());
     // Allow UI and IO threads to do blocking IO on shutdown, since we do a lot
     // of it on shutdown for valid reasons.
     base::ThreadRestrictions::SetIOAllowed(true);
     CHECK(!BrowserList::GetLastActive());
     io_thread()->message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableFunction(&base::ThreadRestrictions::SetIOAllowed, true));
+        base::IgnoreReturn<bool>(

[willchan no longer on Chromium, 2011/11/19 20:58:24]

I'm not sure if the template parameter is necessary. If not, then it'll look
cleaner if you drop it and that would be my preference. If it's necessary, then
sure.

[dcheng, 2011/11/19 21:15:24]

It seems to be necessary in general... except in the bind unittest. Do you know
why type inference works for the unit test but not here?

[willchan no longer on Chromium, 2011/11/19 21:17:55]

Can you show me the compilation errors you encounter?

[dcheng, 2011/11/19 21:21:27]

  CXX(target) out/Debug/obj.target/browser/chrome/browser/browser_process_impl.o
chrome/browser/browser_process_impl.cc: In member function 'virtual unsigned int
BrowserProcessImpl::ReleaseModule()':
chrome/browser/browser_process_impl.cc:329: error: no matching function for call
to
'IgnoreReturn(base::internal::InvokerStorageHolder<base::internal::InvokerStorage1<bool
(*)(bool), bool> >)'
make: *** [out/Debug/obj.target/browser/chrome/browser/browser_process_impl.o]
Error 1

+            base::Bind(&base::ThreadRestrictions::SetIOAllowed, true)));
 
 #if defined(OS_MACOSX)
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        NewRunnableFunction(ChromeBrowserMainPartsMac::DidEndMainMessageLoop));
+        base::Bind(ChromeBrowserMainPartsMac::DidEndMainMessageLoop));
 #endif
     MessageLoop::current()->Quit();
   }
   return module_ref_count_;
 }
 
 void BrowserProcessImpl::EndSession() {
   // Mark all the profiles as clean.
   ProfileManager* pm = profile_manager();
   std::vector<Profile*> profiles(pm->GetLoadedProfiles());
@@ skipping 10 matching lines @@
   }
 
   // We must write that the profile and metrics service shutdown cleanly,
   // otherwise on startup we'll think we crashed. So we block until done and
   // then proceed with normal shutdown.
 #if defined(USE_X11)
   //  Can't run a local loop on linux. Instead create a waitable event.
   scoped_ptr<base::WaitableEvent> done_writing(
       new base::WaitableEvent(false, false));
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      NewRunnableFunction(Signal, done_writing.get()));
+      base::Bind(Signal, done_writing.get()));
   // If all file writes haven't cleared in the timeout, leak the WaitableEvent
   // so that there's no race to reference it in Signal().
   if (!done_writing->TimedWait(
       base::TimeDelta::FromSeconds(kEndSessionTimeoutSeconds)))
     ignore_result(done_writing.release());
 
 #elif defined(OS_WIN)
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      NewRunnableFunction(PostQuit, MessageLoop::current()));
+      base::Bind(PostQuit, MessageLoop::current()));
   int quits_received = 0;
   do {
     MessageLoop::current()->Run();
     ++quits_received;
   } while (!g_end_session_file_thread_has_completed);
   // If we did get extra quits, then we should re-post them to the message loop.
   while (--quits_received > 0)
     MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 #else
   NOTIMPLEMENTED();
@@ skipping 715 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartBackgroundInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)