Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

chrome/browser/ui/browser_commands.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_commands.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_editor.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/printing/print_view_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_delegate.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/search/search.h"
 #include "chrome/browser/ui/search/search_model.h"
 #include "chrome/browser/ui/status_bubble.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 30 matching lines @@
 using content::Referrer;
 using content::SSLStatus;
 using content::UserMetricsAction;
 using content::WebContents;
 
 namespace chrome {
 namespace {
 
 WebContents* GetOrCloneTabForDisposition(Browser* browser,
                                          WindowOpenDisposition disposition) {
-  TabContents* current_tab = browser->GetActiveTabContents();
+  TabContents* current_tab = chrome::GetActiveTabContents(browser);
   switch (disposition) {
     case NEW_FOREGROUND_TAB:
     case NEW_BACKGROUND_TAB: {
       current_tab = current_tab->Clone();
       browser->tab_strip_model()->AddTabContents(
           current_tab, -1, content::PAGE_TRANSITION_LINK,
           disposition == NEW_FOREGROUND_TAB ? TabStripModel::ADD_ACTIVE :
                                               TabStripModel::ADD_NONE);
       break;
     }
     case NEW_WINDOW: {
       current_tab = current_tab->Clone();
       Browser* b = Browser::Create(browser->profile());
       b->tab_strip_model()->AddTabContents(
           current_tab, -1, content::PAGE_TRANSITION_LINK,
           TabStripModel::ADD_ACTIVE);
       b->window()->Show();
       break;
     }
     default:
       break;
   }
   return current_tab->web_contents();
 }
 
 void ReloadInternal(Browser* browser,
                     WindowOpenDisposition disposition,
                     bool ignore_cache) {
   // If we are showing an interstitial, treat this as an OpenURL.
-  WebContents* current_tab = browser->GetActiveWebContents();
+  WebContents* current_tab = chrome::GetActiveWebContents(browser);
   if (current_tab && current_tab->ShowingInterstitialPage()) {
     NavigationEntry* entry = current_tab->GetController().GetActiveEntry();
     DCHECK(entry);  // Should exist if interstitial is showing.
     browser->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* web_contents = GetOrCloneTabForDisposition(browser, disposition);
   web_contents->UserGestureDone();
   if (!web_contents->FocusLocationBarByDefault())
     web_contents->Focus();
   if (ignore_cache)
     web_contents->GetController().ReloadIgnoringCache(true);
   else
     web_contents->GetController().Reload(true);
 }
 
 bool HasConstrainedWindow(const Browser* browser) {
-  TabContents* tab_contents = browser->GetActiveTabContents();
+  TabContents* tab_contents = GetActiveTabContents(browser);
   return tab_contents && tab_contents->constrained_window_tab_helper()->
       constrained_window_count();
 }
 
 bool PrintPreviewShowing(const Browser* browser) {
-  TabContents* contents = browser->GetActiveTabContents();
+  TabContents* contents = GetActiveTabContents(browser);
   printing::PrintPreviewTabController* controller =
       printing::PrintPreviewTabController::GetInstance();
   return controller && (controller->GetPrintPreviewForTab(contents) ||
                         controller->is_creating_print_preview_tab());
 }
 
 }  // namespace
 
 bool IsCommandEnabled(Browser* browser, int command) {
   return browser->command_controller()->command_updater()->IsCommandEnabled(
@@ skipping 31 matching lines @@
 
 void RemoveCommandObserver(Browser* browser,
                            int command,
                            CommandObserver* observer) {
   browser->command_controller()->command_updater()->RemoveCommandObserver(
       command, observer);
 }
 
 int GetContentRestrictions(const Browser* browser) {
   int content_restrictions = 0;
-  WebContents* current_tab = browser->GetActiveWebContents();
+  WebContents* current_tab = GetActiveWebContents(browser);
   if (current_tab) {
     content_restrictions = current_tab->GetContentRestrictions();
     NavigationEntry* active_entry =
         current_tab->GetController().GetActiveEntry();
     // See comment in UpdateCommandsForTabState about why we call url().
     if (!download_util::IsSavableURL(
             active_entry ? active_entry->GetURL() : GURL()) ||
         current_tab->ShowingInterstitialPage())
       content_restrictions |= content::CONTENT_RESTRICTION_SAVE;
     if (current_tab->ShowingInterstitialPage())
@@ skipping 41 matching lines @@
 
 void OpenWindowWithRestoredTabs(Profile* profile) {
   TabRestoreService* service = TabRestoreServiceFactory::GetForProfile(profile);
   if (service)
     service->RestoreMostRecentEntry(NULL);
 }
 
 void OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser* browser = browser::FindOrCreateTabbedBrowser(
       profile->GetOffTheRecordProfile());
-  browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_LINK);
+  AddSelectedTabWithURL(browser, url, content::PAGE_TRANSITION_LINK);
   browser->window()->Show();
 }
 
 bool CanGoBack(const Browser* browser) {
-  return browser->GetActiveWebContents()->GetController().CanGoBack();
+  return GetActiveWebContents(browser)->GetController().CanGoBack();
 }
 
 void GoBack(Browser* browser, WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Back"));
 
-  TabContents* current_tab = browser->GetActiveTabContents();
+  TabContents* current_tab = GetActiveTabContents(browser);
   if (CanGoBack(browser)) {
     WebContents* new_tab = GetOrCloneTabForDisposition(browser, disposition);
     // If we are on an interstitial page and clone the tab, it won't be copied
     // to the new tab, so we don't need to go back.
     if (current_tab->web_contents()->ShowingInterstitialPage() &&
         (new_tab != current_tab->web_contents()))
       return;
     new_tab->GetController().GoBack();
   }
 }
 
 bool CanGoForward(const Browser* browser) {
-  return browser->GetActiveWebContents()->GetController().CanGoForward();
+  return GetActiveWebContents(browser)->GetController().CanGoForward();
 }
 
 void GoForward(Browser* browser, WindowOpenDisposition disposition) {
   content::RecordAction(UserMetricsAction("Forward"));
   if (CanGoForward(browser)) {
     GetOrCloneTabForDisposition(browser, disposition)->
         GetController().GoForward();
   }
 }
 
@@ skipping 60 matching lines @@
 
   DCHECK(browser->profile()->GetExtensionService());
   if (browser->profile()->GetExtensionService()->IsInstalledApp(url)) {
     AppLauncherHandler::RecordAppLaunchType(
         extension_misc::APP_LAUNCH_OMNIBOX_LOCATION);
   }
 }
 
 void Stop(Browser* browser) {
   content::RecordAction(UserMetricsAction("Stop"));
-  browser->GetActiveWebContents()->Stop();
+  GetActiveWebContents(browser)->Stop();
 }
 
 #if !defined(OS_WIN)
 void NewWindow(Browser* browser) {
   NewEmptyWindow(browser->profile()->GetOriginalProfile());
 }
 
 void NewIncognitoWindow(Browser* browser) {
   NewEmptyWindow(browser->profile()->GetOffTheRecordProfile());
 }
 #endif  // OS_WIN
 
 void CloseWindow(Browser* browser) {
   content::RecordAction(UserMetricsAction("CloseWindow"));
   browser->window()->Close();
 }
 
 void NewTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("NewTab"));
   // TODO(asvitkine): This is invoked programmatically from several places.
   // Audit the code and change it so that the histogram only gets collected for
   // user-initiated commands.
   UMA_HISTOGRAM_ENUMERATION("Tab.NewTab", TabStripModel::NEW_TAB_COMMAND,
                             TabStripModel::NEW_TAB_ENUM_COUNT);
 
   if (browser->is_type_tabbed()) {
     browser->AddBlankTab(true);
-    browser->GetActiveWebContents()->GetView()->RestoreFocus();
+    GetActiveWebContents(browser)->GetView()->RestoreFocus();
   } else {
     Browser* b = browser::FindOrCreateTabbedBrowser(browser->profile());
     b->AddBlankTab(true);
     b->window()->Show();
     // The call to AddBlankTab above did not set the focus to the tab as its
     // window was not active, so we have to do it explicitly.
     // See http://crbug.com/6380.
-    b->GetActiveWebContents()->GetView()->RestoreFocus();
+    chrome::GetActiveWebContents(b)->GetView()->RestoreFocus();
   }
 }
 
 void CloseTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   browser->tab_strip_model()->CloseSelectedTabs();
 }
 
 void RestoreTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("RestoreTab"));
@@ skipping 39 matching lines @@
 }
 
 void MoveTabPrevious(Browser* browser) {
   content::RecordAction(UserMetricsAction("MoveTabPrevious"));
   browser->tab_strip_model()->MoveTabPrevious();
 }
 
 void SelectNumberedTab(Browser* browser, int index) {
   if (index < browser->tab_count()) {
     content::RecordAction(UserMetricsAction("SelectNumberedTab"));
-    browser->ActivateTabAt(index, true);
+    ActivateTabAt(browser, index, true);
   }
 }
 
 void SelectLastTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("SelectLastTab"));
   browser->tab_strip_model()->SelectLastTab();
 }
 
 void DuplicateTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("Duplicate"));
   browser->DuplicateContentsAt(browser->active_index());
 }
 
 bool CanDuplicateTab(const Browser* browser) {
-  WebContents* contents = browser->GetActiveWebContents();
+  WebContents* contents = GetActiveWebContents(browser);
   return contents && contents->GetController().GetLastCommittedEntry();
 }
 
 void WriteCurrentURLToClipboard(Browser* browser) {
   // TODO(ericu): There isn't currently a metric for this.  Should there be?
   // We don't appear to track the action when it comes from the
   // RenderContextViewMenu.
 
-  WebContents* contents = browser->GetActiveWebContents();
+  WebContents* contents = GetActiveWebContents(browser);
   if (!browser->toolbar_model()->ShouldDisplayURL())
     return;
 
   chrome_common_net::WriteURLToClipboard(
       contents->GetURL(),
       browser->profile()->GetPrefs()->GetString(prefs::kAcceptLanguages),
       g_browser_process->clipboard());
 }
 
 void ConvertPopupToTabbedBrowser(Browser* browser) {
@@ skipping 12 matching lines @@
 
 void BookmarkCurrentPage(Browser* browser) {
   content::RecordAction(UserMetricsAction("Star"));
 
   BookmarkModel* model = browser->profile()->GetBookmarkModel();
   if (!model || !model->IsLoaded())
     return;  // Ignore requests until bookmarks are loaded.
 
   GURL url;
   string16 title;
-  TabContents* tab = browser->GetActiveTabContents();
+  TabContents* tab = GetActiveTabContents(browser);
   bookmark_utils::GetURLAndTitleToBookmark(tab->web_contents(), &url, &title);
   bool was_bookmarked = model->IsBookmarked(url);
   if (!was_bookmarked && browser->profile()->IsOffTheRecord()) {
     // If we're incognito the favicon may not have been saved. Save it now
     // so that bookmarks have an icon for the page.
     tab->favicon_tab_helper()->SaveFavicon();
   }
   bookmark_utils::AddIfNotBookmarked(model, url, title);
   // Make sure the model actually added a bookmark before showing the star. A
   // bookmark isn't created if the url is invalid.
@@ skipping 20 matching lines @@
   return browser->tab_count() > 1 && CanBookmarkCurrentPage(browser);
 }
 
 #if !defined(OS_WIN)
 void PinCurrentPageToStartScreen(Browser* browser) {
 }
 #endif
 
 void SavePage(Browser* browser) {
   content::RecordAction(UserMetricsAction("SavePage"));
-  WebContents* current_tab = browser->GetActiveWebContents();
+  WebContents* current_tab = GetActiveWebContents(browser);
   if (current_tab && current_tab->GetContentsMimeType() == "application/pdf")
     content::RecordAction(UserMetricsAction("PDF.SavePage"));
   current_tab->OnSavePage();
 }
 
 bool CanSavePage(const Browser* browser) {
   // LocalState can be NULL in tests.
   if (g_browser_process->local_state() &&
       !g_browser_process->local_state()->GetBoolean(
       prefs::kAllowFileSelectionDialogs)) {
@@ skipping 28 matching lines @@
 void ShowChromeToMobileBubble(Browser* browser) {
   // Only show the bubble if the window is active, otherwise we may get into
   // weird situations where the bubble is deleted as soon as it is shown.
   if (browser->window()->IsActive())
     browser->window()->ShowChromeToMobileBubble();
 }
 
 void Print(Browser* browser) {
   if (g_browser_process->local_state()->GetBoolean(
           prefs::kPrintPreviewDisabled)) {
-    browser->GetActiveTabContents()->print_view_manager()->PrintNow();
+    GetActiveTabContents(browser)->print_view_manager()->PrintNow();
   } else {
-    browser->GetActiveTabContents()->print_view_manager()->PrintPreviewNow();
+    GetActiveTabContents(browser)->print_view_manager()->
+        PrintPreviewNow();
   }
 }
 
 bool CanPrint(const Browser* browser) {
   // LocalState can be NULL in tests.
   if (g_browser_process->local_state() &&
       !g_browser_process->local_state()->GetBoolean(prefs::kPrintingEnabled)) {
     return false;
   }
 
   // Do not print when a constrained window is showing. It's confusing.
   return !(HasConstrainedWindow(browser) ||
       GetContentRestrictions(browser) & content::CONTENT_RESTRICTION_PRINT);
 }
 
 void AdvancedPrint(Browser* browser) {
-  browser->GetActiveTabContents()->print_view_manager()->AdvancedPrintNow();
+  GetActiveTabContents(browser)->print_view_manager()->
+      AdvancedPrintNow();
 }
 
 bool CanAdvancedPrint(const Browser* browser) {
   // LocalState can be NULL in tests.
   if (g_browser_process->local_state() &&
       !g_browser_process->local_state()->GetBoolean(prefs::kPrintingEnabled)) {
     return false;
   }
 
   // It is always possible to advanced print when print preview is visible.
   return PrintPreviewShowing(browser) || CanPrint(browser);
 }
 
 void PrintToDestination(Browser* browser) {
-  browser->GetActiveTabContents()->print_view_manager()->PrintToDestination();
+  GetActiveTabContents(browser)->print_view_manager()->PrintToDestination();
 }
 
 void EmailPageLocation(Browser* browser) {
   content::RecordAction(UserMetricsAction("EmailPageLocation"));
-  WebContents* wc = browser->GetActiveWebContents();
+  WebContents* wc = GetActiveWebContents(browser);
   DCHECK(wc);
 
   std::string title = net::EscapeQueryParamValue(
       UTF16ToUTF8(wc->GetTitle()), false);
   std::string page_url = net::EscapeQueryParamValue(wc->GetURL().spec(), false);
   std::string mailto = std::string("mailto:?subject=Fwd:%20") +
       title + "&body=%0A%0A" + page_url;
   platform_util::OpenExternal(GURL(mailto));
 }
 
 bool CanEmailPageLocation(const Browser* browser) {
   return browser->toolbar_model()->ShouldDisplayURL() &&
-      browser->GetActiveWebContents()->GetURL().is_valid();
+      GetActiveWebContents(browser)->GetURL().is_valid();
 }
 
 void Cut(Browser* browser) {
   content::RecordAction(UserMetricsAction("Cut"));
   browser->window()->Cut();
 }
 
 void Copy(Browser* browser) {
   content::RecordAction(UserMetricsAction("Copy"));
   browser->window()->Copy();
@@ skipping 20 matching lines @@
 }
 
 void FindInPage(Browser* browser, bool find_next, bool forward_direction) {
   ShowFindBar(browser);
   if (find_next) {
     string16 find_text;
 #if defined(OS_MACOSX)
     // We always want to search for the contents of the find pasteboard on OS X.
     find_text = GetFindPboardText();
 #endif
-    browser->GetActiveTabContents()->
+    GetActiveTabContents(browser)->
         find_tab_helper()->StartFinding(find_text,
                                         forward_direction,
                                         false);  // Not case sensitive.
   }
 }
 
 void Zoom(Browser* browser, content::PageZoom zoom) {
   if (browser->is_devtools())
     return;
 
   content::RenderViewHost* host =
-      browser->GetActiveWebContents()->GetRenderViewHost();
+      GetActiveWebContents(browser)->GetRenderViewHost();
   if (zoom == content::PAGE_ZOOM_RESET) {
     host->SetZoomLevel(0);
     content::RecordAction(UserMetricsAction("ZoomNormal"));
     return;
   }
 
-  double current_zoom_level = browser->GetActiveWebContents()->GetZoomLevel();
+  double current_zoom_level = GetActiveWebContents(browser)->GetZoomLevel();
   double default_zoom_level =
       browser->profile()->GetPrefs()->GetDouble(prefs::kDefaultZoomLevel);
 
   // Generate a vector of zoom levels from an array of known presets along with
   // the default level added if necessary.
   std::vector<double> zoom_levels =
       chrome_page_zoom::PresetZoomLevels(default_zoom_level);
 
   if (zoom == content::PAGE_ZOOM_OUT) {
     // Iterate through the zoom levels in reverse order to find the next
@@ skipping 64 matching lines @@
   browser->window()->RotatePaneFocus(false);
 }
 
 void ToggleDevToolsWindow(Browser* browser, DevToolsToggleAction action) {
   if (action == DEVTOOLS_TOGGLE_ACTION_SHOW_CONSOLE)
     content::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
   else
     content::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
 
   DevToolsWindow::ToggleDevToolsWindow(
-      browser->GetActiveWebContents()->GetRenderViewHost(),
+      GetActiveWebContents(browser)->GetRenderViewHost(),
       action);
 }
 
 bool CanOpenTaskManager() {
 #if defined(OS_WIN)
   // In metro we can't display the task manager, as it is a native window.
   return !base::win::IsMetroProcess();
 #else
   return true;
 #endif
@@ skipping 25 matching lines @@
 void ShowAvatarMenu(Browser* browser) {
   browser->window()->ShowAvatarBubbleFromAvatarButton();
 }
 
 void OpenUpdateChromeDialog(Browser* browser) {
   content::RecordAction(UserMetricsAction("UpdateChrome"));
   browser->window()->ShowUpdateChromeDialog();
 }
 
 void ToggleSpeechInput(Browser* browser) {
-  browser->GetActiveWebContents()->GetRenderViewHost()->ToggleSpeechInput();
+  GetActiveWebContents(browser)->GetRenderViewHost()->ToggleSpeechInput();
 }
 
 void ViewSource(Browser* browser, TabContents* contents) {
   DCHECK(contents);
 
   NavigationEntry* active_entry =
     contents->web_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
   ViewSource(browser, contents, active_entry->GetURL(),
              active_entry->GetContentState());
 }
 
 void ViewSource(Browser* browser,
                 TabContents* contents,
                 const GURL& url,
                 const std::string& content_state) {
   content::RecordAction(UserMetricsAction("ViewSource"));
   DCHECK(contents);
 
   TabContents* view_source_contents = contents->Clone();
   view_source_contents->web_contents()->GetController().PruneAllButActive();
   NavigationEntry* active_entry =
       view_source_contents->web_contents()->GetController().GetActiveEntry();
   if (!active_entry)
     return;
 
-  GURL view_source_url = GURL(chrome::kViewSourceScheme + std::string(":") +
+  GURL view_source_url = GURL(kViewSourceScheme + std::string(":") +
       url.spec());
   active_entry->SetVirtualURL(view_source_url);
 
   // Do not restore scroller position.
   active_entry->SetContentState(
       webkit_glue::RemoveScrollOffsetFromHistoryState(content_state));
 
   // Do not restore title, derive it from the url.
   active_entry->SetTitle(string16());
 
@@ skipping 15 matching lines @@
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = b->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           browser->window()->GetRestoredBounds().size()));
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
     // WebContents is invisible and won't size it.
     b->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
-    b->AddTab(view_source_contents, content::PAGE_TRANSITION_LINK);
+    chrome::AddTab(b, view_source_contents, content::PAGE_TRANSITION_LINK);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(browser->profile());
   if (session_service)
     session_service->TabRestored(view_source_contents, false);
 }
 
 void ViewSelectedSource(Browser* browser) {
-  ViewSource(browser, browser->GetActiveTabContents());
+  ViewSource(browser, chrome::GetActiveTabContents(browser));
 }
 
 bool CanViewSource(const Browser* browser) {
-  return browser->GetActiveWebContents()->GetController().CanViewSource();
+  return chrome::GetActiveWebContents(browser)->GetController().CanViewSource();
 }
 
 bool CanCreateApplicationShortcuts(const Browser* browser) {
-  return web_app::IsValidUrl(browser->GetActiveWebContents()->GetURL());
+  return web_app::IsValidUrl(chrome::GetActiveWebContents(browser)->GetURL());
 }
 
 void ConvertTabToAppWindow(Browser* browser,
                            content::WebContents* contents) {
   const GURL& url = contents->GetController().GetActiveEntry()->GetURL();
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
 
   int index = browser->tab_strip_model()->GetIndexOfWebContents(contents);
   if (index >= 0)
     browser->tab_strip_model()->DetachTabContentsAt(index);
 
   Browser* app_browser = Browser::CreateWithParams(
       Browser::CreateParams::CreateForApp(
           Browser::TYPE_POPUP, app_name, gfx::Rect(), browser->profile()));
   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();
 }
 
 }  // namespace chrome