base::bind migrations for browser.cc

chrome/browser/ui/browser.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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
 
 #include <algorithm>
 #include <string>
 
 #include "base/base_paths.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 273 matching lines @@
       window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_handler_(TabHandler::CreateTabHandler(this))),
       command_updater_(this),
       toolbar_model_(this),
       chrome_updater_factory_(this),
       is_attempting_to_close_browser_(false),
       cancel_download_confirmation_state_(NOT_PROMPTED),
       show_state_(ui::SHOW_STATE_DEFAULT),
       is_session_restore_(false),
-      method_factory_(this),
+      weak_factory_(this),
       block_command_execution_(false),
       last_blocked_command_id_(-1),
       last_blocked_command_disposition_(CURRENT_TAB),
       pending_web_app_action_(NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_restore_service_delegate_(
               new BrowserTabRestoreServiceDelegate(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           synced_window_delegate_(
               new BrowserSyncedWindowDelegate(this))),
@@ skipping 1409 matching lines @@
 
 #if defined(OS_CHROMEOS)
 void Browser::Search() {
   // Exit fullscreen to show omnibox.
   if (window_->IsFullscreen()) {
     ToggleFullscreenMode(false);
     // ToggleFullscreenMode is asynchronous, so we don't have omnibox
     // visible at this point. Wait for next event cycle which toggles
     // the visibility of omnibox before creating new tab.
     MessageLoop::current()->PostTask(
-        FROM_HERE, method_factory_.NewRunnableMethod(&Browser::Search));
+         FROM_HERE, base::Bind(&Browser::Search, weak_factory_.GetWeakPtr()));

[James Hawkins, 2011/11/22 21:26:30]

This extra space makes the indentation 5 spaces (I think).

[csilv, 2011/11/22 21:31:52]

Done.

     return;
   }
 
   const GURL& url = GetSelectedTabContents()->GetURL();
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
       url.host() == chrome::kChromeUINewTabHost) {
     // If the NTP is showing, focus the omnibox.
     window_->SetFocusToLocationBar(true);
   } else {
     // Otherwise, open the NTP.
@@ skipping 1346 matching lines @@
     session_service->TabRestored(contents_dupe, pinned);
 }
 
 void Browser::CloseFrameAfterDragSession() {
 #if !defined(OS_MACOSX)
   // This is scheduled to run after we return to the message loop because
   // otherwise the frame will think the drag session is still active and ignore
   // the request.
   // TODO(port): figure out what is required here in a cross-platform world
   MessageLoop::current()->PostTask(
-      FROM_HERE, method_factory_.NewRunnableMethod(&Browser::CloseFrame));
+      FROM_HERE, base::Bind(&Browser::CloseFrame, weak_factory_.GetWeakPtr()));
 #endif
 }
 
 void Browser::CreateHistoricalTab(TabContentsWrapper* contents) {
   // We don't create historical tabs for incognito windows or windows without
   // profiles.
   if (!profile() || profile()->IsOffTheRecord())
     return;
 
   // We don't create historical tabs for print preview tabs.
@@ skipping 129 matching lines @@
     }
   }
 
   // Discarded tabs always get reloaded.
   if (IsTabDiscarded(index)) {
     Reload(CURRENT_TAB);
     return;
   }
 
   // If we have any update pending, do it now.
-  if (!chrome_updater_factory_.empty() && old_contents)
+  if (chrome_updater_factory_.HasWeakPtrs() && old_contents)
     ProcessPendingUIUpdates();
 
   // Propagate the profile to the location bar.
   UpdateToolbar(true);
 
   // Update reload/stop state.
   UpdateReloadStopState(new_contents->tab_contents()->IsLoading(), true);
 
   // Update commands to reflect current state.
   UpdateCommandsForTabState();
@@ skipping 77 matching lines @@
 void Browser::TabStripEmpty() {
   // Close the frame after we return to the message loop (not immediately,
   // otherwise it will destroy this object before the stack has a chance to
   // cleanly unwind.)
   // Note: This will be called several times if TabStripEmpty is called several
   //       times. This is because it does not close the window if tabs are
   //       still present.
   // NOTE: If you change to be immediate (no invokeLater) then you'll need to
   //       update BrowserList::CloseAllBrowsers.
   MessageLoop::current()->PostTask(
-      FROM_HERE, method_factory_.NewRunnableMethod(&Browser::CloseFrame));
+      FROM_HERE, base::Bind(&Browser::CloseFrame, weak_factory_.GetWeakPtr()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabContentsDelegate implementation:
 
 // TODO(adriansc): Remove this method once refactoring changed all call sites.
 TabContents* Browser::OpenURLFromTab(TabContents* source,
                                      const GURL& url,
                                      const GURL& referrer,
                                      WindowOpenDisposition disposition,
@@ skipping 1357 matching lines @@
         TabStripModelObserver::TITLE_NOT_LOADING);
   }
 
   // If the only updates were synchronously handled above, we're done.
   if (changed_flags == 0)
     return;
 
   // Save the dirty bits.
   scheduled_updates_[source] |= changed_flags;
 
-  if (chrome_updater_factory_.empty()) {
+  if (!chrome_updater_factory_.HasWeakPtrs()) {
     // No task currently scheduled, start another.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        chrome_updater_factory_.NewRunnableMethod(
-            &Browser::ProcessPendingUIUpdates),
-            kUIUpdateCoalescingTimeMS);
+        base::Bind(&Browser::ProcessPendingUIUpdates,
+                   chrome_updater_factory_.GetWeakPtr()),
+        kUIUpdateCoalescingTimeMS);
   }
 }
 
 void Browser::ProcessPendingUIUpdates() {
 #ifndef NDEBUG
   // Validate that all tabs we have pending updates for exist. This is scary
   // because the pending list must be kept in sync with any detached or
   // deleted tabs.
   for (UpdateMap::const_iterator i = scheduled_updates_.begin();
        i != scheduled_updates_.end(); ++i) {
     bool found = false;
     for (int tab = 0; tab < tab_count(); tab++) {
       if (GetTabContentsAt(tab) == i->first) {
         found = true;
         break;
       }
     }
     DCHECK(found);
   }
 #endif
 
-  chrome_updater_factory_.RevokeAll();
+  chrome_updater_factory_.InvalidateWeakPtrs();
 
   for (UpdateMap::const_iterator i = scheduled_updates_.begin();
        i != scheduled_updates_.end(); ++i) {
     // Do not dereference |contents|, it may be out-of-date!
     const TabContents* contents = i->first;
     unsigned flags = i->second;
 
     if (contents == GetSelectedTabContents()) {
       // Updates that only matter when the tab is selected go here.
 
@@ skipping 165 matching lines @@
   // time when request was initiated and when this method is called, so check
   // for is_attempting_to_close_browser_ flag before proceeding.
   if (is_attempting_to_close_browser_) {
     RemoveFromSet(&tabs_needing_before_unload_fired_, tab);
     RemoveFromSet(&tabs_needing_unload_fired_, tab);
     if (process_now) {
       ProcessPendingTabs();
     } else {
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          method_factory_.NewRunnableMethod(&Browser::ProcessPendingTabs));
+          base::Bind(&Browser::ProcessPendingTabs, weak_factory_.GetWeakPtr()));
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, In-progress download termination handling (private):
 
 bool Browser::CanCloseWithInProgressDownloads() {
   // If we've prompted, we need to hear from the user before we
   // can close.
@@ skipping 358 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }