TabContentsWrapper -> TabContents, part 43.

chrome/browser/ui/browser.cc

 // Copyright (c) 2012 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
@@ skipping 1561 matching lines @@
 void Browser::ShowFindBar() {
   GetFindBarController()->Show();
 }
 
 void Browser::ShowPageInfo(content::WebContents* web_contents,
                            const GURL& url,
                            const SSLStatus& ssl,
                            bool show_history) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents->GetBrowserContext());
-  TabContents* tab_contents =
-      TabContents::GetOwningTabContentsForWebContents(web_contents);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableWebsiteSettings)) {
     window()->ShowWebsiteSettings(
         profile, tab_contents, url, ssl, show_history);
   } else {
     window()->ShowPageInfo(profile, url, ssl, show_history);
   }
 }
 
@@ skipping 635 matching lines @@
     // them. Once they have fired, we'll get a message back saying whether
     // to proceed closing the page or not, which sends us back to this method
     // with the NeedToFireBeforeUnload bit cleared.
     contents->GetRenderViewHost()->FirePageBeforeUnload(false);
     return true;
   }
   return false;
 }
 
 // static
-void Browser::JSOutOfMemoryHelper(WebContents* tab) {
-  TabContents* tab_contents = TabContents::GetOwningTabContentsForWebContents(
-      tab);
+void Browser::JSOutOfMemoryHelper(WebContents* web_contents) {
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
   if (!tab_contents)
     return;
 
   InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
   infobar_helper->AddInfoBar(new SimpleAlertInfoBarDelegate(
       infobar_helper,
       NULL,
       l10n_util::GetStringUTF16(IDS_JS_OUT_OF_MEMORY_PROMPT),
       true));
 }
 
 // static
-void Browser::RegisterProtocolHandlerHelper(WebContents* tab,
+void Browser::RegisterProtocolHandlerHelper(WebContents* web_contents,
                                             const std::string& protocol,
                                             const GURL& url,
                                             const string16& title,
                                             bool user_gesture) {
-  TabContents* tab_contents = TabContents::GetOwningTabContentsForWebContents(
-      tab);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
   if (!tab_contents || tab_contents->profile()->IsOffTheRecord())
     return;
 
   ProtocolHandler handler =
       ProtocolHandler::CreateProtocolHandler(protocol, url, title);
 
   ProtocolHandlerRegistry* registry =
       tab_contents->profile()->GetProtocolHandlerRegistry();
 
   if (!registry->SilentlyHandleRegisterHandlerRequest(handler)) {
@@ skipping 16 matching lines @@
         break;
       }
     }
 
     if (rph_delegate != NULL)
       infobar_helper->AddInfoBar(rph_delegate);
   }
 }
 
 // static
-void Browser::FindReplyHelper(WebContents* tab,
+void Browser::FindReplyHelper(WebContents* web_contents,
                               int request_id,
                               int number_of_matches,
                               const gfx::Rect& selection_rect,
                               int active_match_ordinal,
                               bool final_update) {
-  TabContents* tab_contents = TabContents::GetOwningTabContentsForWebContents(
-      tab);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
   if (!tab_contents || !tab_contents->find_tab_helper())
     return;
 
   tab_contents->find_tab_helper()->HandleFindReply(request_id,
                                                    number_of_matches,
                                                    selection_rect,
                                                    active_match_ordinal,
                                                    final_update);
 }
 
@@ skipping 851 matching lines @@
                              WindowOpenDisposition disposition,
                              const gfx::Rect& initial_pos,
                              bool user_gesture) {
   // No code for this yet.
   DCHECK(disposition != SAVE_TO_DISK);
   // Can't create a new contents for the current tab - invalid case.
   DCHECK(disposition != CURRENT_TAB);
 
   TabContents* source_tab_contents = NULL;
   BlockedContentTabHelper* source_blocked_content = NULL;
-  TabContents* new_tab_contents =
-      TabContents::GetOwningTabContentsForWebContents(new_contents);
+  TabContents* new_tab_contents = TabContents::FromWebContents(new_contents);
   if (!new_tab_contents) {
     new_tab_contents = new TabContents(new_contents);
   }
   if (source) {
-    source_tab_contents =
-        TabContents::GetOwningTabContentsForWebContents(source);
+    source_tab_contents = TabContents::FromWebContents(source);
     source_blocked_content = source_tab_contents->blocked_content_tab_helper();
   }
 
   if (source_tab_contents) {
     // Handle blocking of all contents.
     if (source_blocked_content->all_contents_blocked()) {
       source_blocked_content->AddTabContents(new_tab_contents,
                                              disposition,
                                              initial_pos,
                                              user_gesture);
@@ skipping 47 matching lines @@
           GetActiveTabContents()->core_tab_helper()->GetStatusText());
     }
 
     if (!is_loading && pending_web_app_action_ == UPDATE_SHORTCUT) {
       // Schedule a shortcut update when web application info is available if
       // last committed entry is not NULL. Last committed entry could be NULL
       // when an interstitial page is injected (e.g. bad https certificate,
       // malware site etc). When this happens, we abort the shortcut update.
       NavigationEntry* entry = source->GetController().GetLastCommittedEntry();
       if (entry) {
-        TabContents::GetOwningTabContentsForWebContents(source)->
+        TabContents::FromWebContents(source)->
             extension_tab_helper()->GetApplicationInfo(entry->GetPageID());
       } else {
         pending_web_app_action_ = NONE;
       }
     }
   }
 }
 
 void Browser::CloseContents(WebContents* source) {
   if (is_attempting_to_close_browser_) {
@@ skipping 81 matching lines @@
 }
 
 void Browser::ConvertContentsToApplication(WebContents* contents) {
   const GURL& url = contents->GetController().GetActiveEntry()->GetURL();
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
 
   DetachContents(contents);
   Browser* app_browser = Browser::CreateWithParams(
       Browser::CreateParams::CreateForApp(
           TYPE_POPUP, app_name, gfx::Rect(), profile_));
-  TabContents* tab_contents =
-      TabContents::GetOwningTabContentsForWebContents(contents);
+  TabContents* tab_contents = TabContents::FromWebContents(contents);
   if (!tab_contents)
     tab_contents = new TabContents(contents);
   app_browser->tab_strip_model()->AppendTabContents(tab_contents, true);
 
   contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   contents->GetRenderViewHost()->SyncRendererPrefs();
   app_browser->window()->Show();
 }
 
 gfx::Rect Browser::GetRootWindowResizerRect() const {
   return window_->GetRootWindowResizerRect();
 }
 
-void Browser::BeforeUnloadFired(WebContents* tab,
+void Browser::BeforeUnloadFired(WebContents* web_contents,
                                 bool proceed,
                                 bool* proceed_to_fire_unload) {
   if (!is_attempting_to_close_browser_) {
     *proceed_to_fire_unload = proceed;
     if (!proceed)
-      tab->SetClosedByUserGesture(false);
+      web_contents->SetClosedByUserGesture(false);
     return;
   }
 
   if (!proceed) {
     CancelWindowClose();
     *proceed_to_fire_unload = false;
-    tab->SetClosedByUserGesture(false);
+    web_contents->SetClosedByUserGesture(false);
     return;
   }
 
-  if (RemoveFromSet(&tabs_needing_before_unload_fired_, tab)) {
+  if (RemoveFromSet(&tabs_needing_before_unload_fired_, web_contents)) {
     // Now that beforeunload has fired, put the tab on the queue to fire
     // unload.
-    tabs_needing_unload_fired_.insert(tab);
+    tabs_needing_unload_fired_.insert(web_contents);
     ProcessPendingTabs();
     // We want to handle firing the unload event ourselves since we want to
     // fire all the beforeunload events before attempting to fire the unload
     // events should the user cancel closing the browser.
     *proceed_to_fire_unload = false;
     return;
   }
 
   *proceed_to_fire_unload = true;
 }
@@ skipping 12 matching lines @@
 void Browser::RenderWidgetShowing() {
   window_->DisableInactiveFrame();
 }
 
 int Browser::GetExtraRenderViewHeight() const {
   return window_->GetExtraRenderViewHeight();
 }
 
 void Browser::OnStartDownload(WebContents* source,
                               content::DownloadItem* download) {
-  TabContents* tab_contents =
-      TabContents::GetOwningTabContentsForWebContents(source);
+  TabContents* tab_contents = TabContents::FromWebContents(source);
   TabContents* constrained = GetConstrainingTabContents(tab_contents);
   if (constrained != tab_contents) {
     // Download in a constrained popup is shown in the tab that opened it.
     WebContents* constrained_tab = constrained->web_contents();
     constrained_tab->GetDelegate()->OnStartDownload(constrained_tab, download);
     return;
   }
 
   if (!window())
     return;
@@ skipping 35 matching lines @@
                                  const std::string& frame_content_state) {
   DCHECK(source);
   TabContents* tab_contents = GetTabContentsAt(
       tab_strip_model_->GetIndexOfWebContents(source));
   ViewSource(tab_contents, frame_url, frame_content_state);
 }
 
 void Browser::ShowRepostFormWarningDialog(WebContents* source) {
   browser::ShowTabModalConfirmDialog(
       new RepostFormWarningController(source),
-      TabContents::GetOwningTabContentsForWebContents(source));
+      TabContents::FromWebContents(source));
 }
 
 bool Browser::ShouldAddNavigationToHistory(
     const history::HistoryAddPageArgs& add_page_args,
     content::NavigationType navigation_type) {
   // Don't update history if running as app.
   return !IsApplication();
 }
 
 bool Browser::ShouldCreateWebContents(
@@ skipping 34 matching lines @@
       content::Source<Profile>(profile_),
       content::Details<RetargetingDetails>(&details));
 }
 
 void Browser::ContentRestrictionsChanged(WebContents* source) {
   UpdateCommandsForContentRestrictionState();
 }
 
 void Browser::RendererUnresponsive(WebContents* source) {
   // Ignore hangs if print preview is open.
-  TabContents* tab_contents =
-      TabContents::GetOwningTabContentsForWebContents(source);
+  TabContents* tab_contents = TabContents::FromWebContents(source);
   if (tab_contents) {
     printing::PrintPreviewTabController* controller =
         printing::PrintPreviewTabController::GetInstance();
     if (controller) {
       TabContents* preview_tab =
           controller->GetPrintPreviewForTab(tab_contents);
       if (preview_tab && preview_tab != tab_contents) {
         return;
       }
     }
   }
 
   browser::ShowHungRendererDialog(source);
 }
 
 void Browser::RendererResponsive(WebContents* source) {
   browser::HideHungRendererDialog(source);
 }
 
 void Browser::WorkerCrashed(WebContents* source) {
-  TabContents* tab_contents =
-      TabContents::GetOwningTabContentsForWebContents(source);
+  TabContents* tab_contents = TabContents::FromWebContents(source);
   InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
   infobar_helper->AddInfoBar(new SimpleAlertInfoBarDelegate(
       infobar_helper,
       NULL,
       l10n_util::GetStringUTF16(IDS_WEBWORKER_CRASHED_PROMPT),
       true));
 }
 
-void Browser::DidNavigateMainFramePostCommit(WebContents* tab) {
-  if (tab == GetActiveWebContents())
+void Browser::DidNavigateMainFramePostCommit(WebContents* web_contents) {
+  if (web_contents == GetActiveWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
-void Browser::DidNavigateToPendingEntry(WebContents* tab) {
-  if (tab == GetActiveWebContents())
+void Browser::DidNavigateToPendingEntry(WebContents* web_contents) {
+  if (web_contents == GetActiveWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 content::JavaScriptDialogCreator* Browser::GetJavaScriptDialogCreator() {
   return GetJavaScriptDialogCreatorInstance();
 }
 
-content::ColorChooser* Browser::OpenColorChooser(WebContents* tab,
+content::ColorChooser* Browser::OpenColorChooser(WebContents* web_contents,
                                                  int color_chooser_id,
                                                  SkColor color) {
 #if defined(OS_WIN)
   // On Windows, only create a color chooser if one doesn't exist, because we
   // can't close the old color chooser dialog.
   if (!color_chooser_.get())
-    color_chooser_.reset(content::ColorChooser::Create(color_chooser_id, tab,
+    color_chooser_.reset(content::ColorChooser::Create(color_chooser_id,
+                                                       web_contents,
                                                        color));
 #else
   if (color_chooser_.get())
     color_chooser_->End();
-  color_chooser_.reset(content::ColorChooser::Create(color_chooser_id, tab,
+  color_chooser_.reset(content::ColorChooser::Create(color_chooser_id,
+                                                     web_contents,
                                                      color));
 #endif
   return color_chooser_.get();
 }
 
 void Browser::DidEndColorChooser() {
   color_chooser_.reset();
 }
 
-void Browser::RunFileChooser(WebContents* tab,
+void Browser::RunFileChooser(WebContents* web_contents,
                              const content::FileChooserParams& params) {
-  FileSelectHelper::RunFileChooser(tab, params);
+  FileSelectHelper::RunFileChooser(web_contents, params);
 }
 
-void Browser::EnumerateDirectory(WebContents* tab,
+void Browser::EnumerateDirectory(WebContents* web_contents,
                                  int request_id,
                                  const FilePath& path) {
-  FileSelectHelper::EnumerateDirectory(tab, request_id, path);
+  FileSelectHelper::EnumerateDirectory(web_contents, request_id, path);
 }
 
-void Browser::ToggleFullscreenModeForTab(WebContents* tab,
+void Browser::ToggleFullscreenModeForTab(WebContents* web_contents,
                                          bool enter_fullscreen) {
-  fullscreen_controller_->ToggleFullscreenModeForTab(tab, enter_fullscreen);
+  fullscreen_controller_->ToggleFullscreenModeForTab(web_contents,
+                                                     enter_fullscreen);
 }
 
-bool Browser::IsFullscreenForTabOrPending(const WebContents* tab) const {
-  return fullscreen_controller_->IsFullscreenForTabOrPending(tab);
+bool Browser::IsFullscreenForTabOrPending(
+    const WebContents* web_contents) const {
+  return fullscreen_controller_->IsFullscreenForTabOrPending(web_contents);
 }
 
-void Browser::JSOutOfMemory(WebContents* tab) {
-  JSOutOfMemoryHelper(tab);
+void Browser::JSOutOfMemory(WebContents* web_contents) {
+  JSOutOfMemoryHelper(web_contents);
 }
 
-void Browser::RegisterProtocolHandler(WebContents* tab,
+void Browser::RegisterProtocolHandler(WebContents* web_contents,
                                       const std::string& protocol,
                                       const GURL& url,
                                       const string16& title,
                                       bool user_gesture) {
-  RegisterProtocolHandlerHelper(tab, protocol, url, title, user_gesture);
+  RegisterProtocolHandlerHelper(
+      web_contents, protocol, url, title, user_gesture);
 }
 
 void Browser::RegisterIntentHandler(
-    WebContents* tab,
+    WebContents* web_contents,
     const webkit_glue::WebIntentServiceData& data,
     bool user_gesture) {
-  RegisterIntentHandlerHelper(tab, data, user_gesture);
+  RegisterIntentHandlerHelper(web_contents, data, user_gesture);
 }
 
 void Browser::WebIntentDispatch(
-    WebContents* tab, content::WebIntentsDispatcher* intents_dispatcher) {
+    WebContents* web_contents,
+    content::WebIntentsDispatcher* intents_dispatcher) {
   if (!web_intents::IsWebIntentsEnabledForProfile(profile_))
     return;
 
   UMA_HISTOGRAM_COUNTS("WebIntents.Dispatch", 1);
 
-  TabContents* tab_contents =
-      TabContents::GetOwningTabContentsForWebContents(tab);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
   tab_contents->web_intent_picker_controller()->SetIntentsDispatcher(
       intents_dispatcher);
   tab_contents->web_intent_picker_controller()->ShowDialog(
       intents_dispatcher->GetIntent().action,
       intents_dispatcher->GetIntent().type);
 }
 
 void Browser::UpdatePreferredSize(WebContents* source,
                                   const gfx::Size& pref_size) {
   window_->UpdatePreferredSize(source, pref_size);
 }
 
 void Browser::ResizeDueToAutoResize(WebContents* source,
                                     const gfx::Size& new_size) {
   window_->ResizeDueToAutoResize(source, new_size);
 }
 
-void Browser::FindReply(WebContents* tab,
+void Browser::FindReply(WebContents* web_contents,
                         int request_id,
                         int number_of_matches,
                         const gfx::Rect& selection_rect,
                         int active_match_ordinal,
                         bool final_update) {
-  FindReplyHelper(tab, request_id, number_of_matches, selection_rect,
+  FindReplyHelper(web_contents, request_id, number_of_matches, selection_rect,
                   active_match_ordinal, final_update);
 }
 
-void Browser::RequestToLockMouse(WebContents* tab,
+void Browser::RequestToLockMouse(WebContents* web_contents,
                                  bool user_gesture,
                                  bool last_unlocked_by_target) {
-  fullscreen_controller_->RequestToLockMouse(tab,
+  fullscreen_controller_->RequestToLockMouse(web_contents,
                                              user_gesture,
                                              last_unlocked_by_target);
 }
 
 void Browser::LostMouseLock() {
   fullscreen_controller_->LostMouseLock();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CoreTabHelperDelegate implementation:
@@ skipping 925 matching lines @@
   if (HasCompletedUnloadProcessing()) {
     // We've finished all the unload events and can proceed to close the
     // browser.
     OnWindowClosing();
     return;
   }
 
   // Process beforeunload tabs first. When that queue is empty, process
   // unload tabs.
   if (!tabs_needing_before_unload_fired_.empty()) {
-    WebContents* tab = *(tabs_needing_before_unload_fired_.begin());
+    WebContents* web_contents = *(tabs_needing_before_unload_fired_.begin());
     // Null check render_view_host here as this gets called on a PostTask and
     // the tab's render_view_host may have been nulled out.
-    if (tab->GetRenderViewHost()) {
-      tab->GetRenderViewHost()->FirePageBeforeUnload(false);
+    if (web_contents->GetRenderViewHost()) {
+      web_contents->GetRenderViewHost()->FirePageBeforeUnload(false);
     } else {
-      ClearUnloadState(tab, true);
+      ClearUnloadState(web_contents, true);
     }
   } else if (!tabs_needing_unload_fired_.empty()) {
     // We've finished firing all beforeunload events and can proceed with unload
     // events.
     // TODO(ojan): We should add a call to browser_shutdown::OnShutdownStarting
     // somewhere around here so that we have accurate measurements of shutdown
     // time.
     // TODO(ojan): We can probably fire all the unload events in parallel and
     // get a perf benefit from that in the cases where the tab hangs in it's
     // unload handler or takes a long time to page in.
-    WebContents* tab = *(tabs_needing_unload_fired_.begin());
+    WebContents* web_contents = *(tabs_needing_unload_fired_.begin());
     // Null check render_view_host here as this gets called on a PostTask and
     // the tab's render_view_host may have been nulled out.
-    if (tab->GetRenderViewHost()) {
-      tab->GetRenderViewHost()->ClosePage();
+    if (web_contents->GetRenderViewHost()) {
+      web_contents->GetRenderViewHost()->ClosePage();
     } else {
-      ClearUnloadState(tab, true);
+      ClearUnloadState(web_contents, true);
     }
   } else {
     NOTREACHED();
   }
 }
 
 bool Browser::HasCompletedUnloadProcessing() const {
   return is_attempting_to_close_browser_ &&
       tabs_needing_before_unload_fired_.empty() &&
       tabs_needing_unload_fired_.empty();
@@ skipping 13 matching lines @@
       content::Source<Browser>(this),
       content::NotificationService::NoDetails());
 
   // Inform TabCloseableStateWatcher that closing of window has been canceled.
   TabCloseableStateWatcher* watcher =
       g_browser_process->tab_closeable_state_watcher();
   if (watcher)
     watcher->OnWindowCloseCanceled(this);
 }
 
-bool Browser::RemoveFromSet(UnloadListenerSet* set, WebContents* tab) {
+bool Browser::RemoveFromSet(UnloadListenerSet* set, WebContents* web_contents) {
   DCHECK(is_attempting_to_close_browser_);
 
-  UnloadListenerSet::iterator iter = std::find(set->begin(), set->end(), tab);
+  UnloadListenerSet::iterator iter =
+      std::find(set->begin(), set->end(), web_contents);
   if (iter != set->end()) {
     set->erase(iter);
     return true;
   }
   return false;
 }
 
-void Browser::ClearUnloadState(WebContents* tab, bool process_now) {
+void Browser::ClearUnloadState(WebContents* web_contents, bool process_now) {
   // Closing of browser could be canceled (via IsClosingPermitted) between the
   // 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);
+    RemoveFromSet(&tabs_needing_before_unload_fired_, web_contents);
+    RemoveFromSet(&tabs_needing_unload_fired_, web_contents);
     if (process_now) {
       ProcessPendingTabs();
     } else {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&Browser::ProcessPendingTabs, weak_factory_.GetWeakPtr()));
     }
   }
 }
 
@@ skipping 120 matching lines @@
     OpenURL(OpenURLParams(
         entry->GetURL(), Referrer(), disposition,
         content::PAGE_TRANSITION_RELOAD, false));
     return;
   }
 
   // As this is caused by a user action, give the focus to the page.
   //
   // Also notify RenderViewHostDelegate of the user gesture; this is
   // normally done in Browser::Navigate, but a reload bypasses Navigate.
-  WebContents* tab = GetOrCloneTabForDisposition(disposition);
-  tab->UserGestureDone();
-  if (!tab->FocusLocationBarByDefault())
-    tab->Focus();
+  WebContents* web_contents = GetOrCloneTabForDisposition(disposition);
+  web_contents->UserGestureDone();
+  if (!web_contents->FocusLocationBarByDefault())
+    web_contents->Focus();
   if (ignore_cache)
-    tab->GetController().ReloadIgnoringCache(true);
+    web_contents->GetController().ReloadIgnoringCache(true);
   else
-    tab->GetController().Reload(true);
+    web_contents->GetController().Reload(true);
 }
 
 WebContents* Browser::GetOrCloneTabForDisposition(
        WindowOpenDisposition disposition) {
   TabContents* current_tab = GetActiveTabContents();
   switch (disposition) {
     case NEW_FOREGROUND_TAB:
     case NEW_BACKGROUND_TAB: {
       current_tab = current_tab->Clone();
       tab_strip_model_->AddTabContents(
@@ skipping 314 matching lines @@
   if (contents && !allow_js_access) {
     contents->web_contents()->GetController().LoadURL(
         target_url,
         content::Referrer(),
         content::PAGE_TRANSITION_LINK,
         std::string());  // No extra headers.
   }
 
   return contents != NULL;
 }