Move TabStripModelDelegate off Browser into its own class.

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 65 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 = chrome::GetActiveTabContents(browser);
+  TabContents* current_tab = 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 = chrome::GetActiveWebContents(browser);
+  WebContents* current_tab = 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.
@@ skipping 19 matching lines @@
 bool PrintPreviewShowing(const Browser* browser) {
   TabContents* contents = GetActiveTabContents(browser);
   printing::PrintPreviewTabController* controller =
       printing::PrintPreviewTabController::GetInstance();
   return controller && (controller->GetPrintPreviewForTab(contents) ||
                         controller->is_creating_print_preview_tab());
 }
 
 bool IsNTPModeForInstantExtendedAPI(const Browser* browser) {
   return browser->search_model() &&
-      chrome::search::IsInstantExtendedAPIEnabled(browser->profile()) &&
-      browser->search_model()->mode().is_ntp();
+      search::IsInstantExtendedAPIEnabled(browser->profile()) &&
+          browser->search_model()->mode().is_ntp();
 }
 
 }  // namespace
 
 bool IsCommandEnabled(Browser* browser, int command) {
   return browser->command_controller()->command_updater()->IsCommandEnabled(
       command);
 }
 
 bool SupportsCommand(Browser* browser, int command) {
@@ skipping 75 matching lines @@
         SessionServiceFactory::GetForProfile(profile->GetOriginalProfile());
     if (!session_service ||
         !session_service->RestoreIfNecessary(std::vector<GURL>())) {
       OpenEmptyWindow(profile->GetOriginalProfile());
     }
   }
 }
 
 Browser* OpenEmptyWindow(Profile* profile) {
   Browser* browser = Browser::Create(profile);
-  browser->AddBlankTab(true);
+  AddBlankTab(browser, true);
   browser->window()->Show();
   return browser;
 }
 
 void OpenWindowWithRestoredTabs(Profile* profile) {
   TabRestoreService* service = TabRestoreServiceFactory::GetForProfile(profile);
   if (service)
     service->RestoreMostRecentEntry(NULL);
 }
 
@@ skipping 76 matching lines @@
   if (!location_bar)
     return;
 
   WindowOpenDisposition open_disposition =
       location_bar->GetWindowOpenDisposition();
   if (browser->OpenInstant(open_disposition))
     return;
 
   GURL url(location_bar->GetInputString());
 
-  chrome::NavigateParams params(browser, url,
-                                location_bar->GetPageTransition());
+  NavigateParams params(browser, url, location_bar->GetPageTransition());
   params.disposition = open_disposition;
   // Use ADD_INHERIT_OPENER so that all pages opened by the omnibox at least
   // inherit the opener. In some cases the tabstrip will determine the group
   // should be inherited, in which case the group is inherited instead of the
   // opener.
   params.tabstrip_add_types =
       TabStripModel::ADD_FORCE_INDEX | TabStripModel::ADD_INHERIT_OPENER;
-  chrome::Navigate(&params);
+  Navigate(&params);
 
   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"));
@@ skipping 17 matching lines @@
 
 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);
+    AddBlankTab(browser, true);
     GetActiveWebContents(browser)->GetView()->RestoreFocus();
   } else {
     Browser* b = browser::FindOrCreateTabbedBrowser(browser->profile());
-    b->AddBlankTab(true);
+    AddBlankTab(b, 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.
-    chrome::GetActiveWebContents(b)->GetView()->RestoreFocus();
+    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 50 matching lines @@
   }
 }
 
 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());
+  DuplicateTabAt(browser, browser->active_index());
 }
 
 bool CanDuplicateTab(const Browser* browser) {
   WebContents* contents = GetActiveWebContents(browser);
   return contents && contents->GetController().GetLastCommittedEntry();
 }
 
+void DuplicateTabAt(Browser* browser, int index) {
+  TabContents* contents = GetTabContentsAt(browser, index);
+  CHECK(contents);
+  TabContents* contents_dupe = contents->Clone();
+
+  bool pinned = false;
+  if (browser->CanSupportWindowFeature(Browser::FEATURE_TABSTRIP)) {
+    // If this is a tabbed browser, just create a duplicate tab inside the same
+    // window next to the tab being duplicated.
+    int index = browser->tab_strip_model()->GetIndexOfTabContents(contents);
+    pinned = browser->tab_strip_model()->IsTabPinned(index);
+    int add_types = TabStripModel::ADD_ACTIVE |
+        TabStripModel::ADD_INHERIT_GROUP |
+        (pinned ? TabStripModel::ADD_PINNED : 0);
+    browser->tab_strip_model()->InsertTabContentsAt(
+        index + 1, contents_dupe, add_types);
+  } else {
+    Browser* browser = NULL;
+    if (browser->is_app()) {
+      CHECK(!browser->is_type_popup());
+      CHECK(!browser->is_type_panel());
+      browser = Browser::CreateWithParams(
+          Browser::CreateParams::CreateForApp(Browser::TYPE_POPUP,
+                                              browser->app_name(),
+                                              gfx::Rect(),
+                                              browser->profile()));
+    } else if (browser->is_type_popup()) {
+      browser = Browser::CreateWithParams(
+          Browser::CreateParams(Browser::TYPE_POPUP, browser->profile()));
+    }
+
+    // Preserve the size of the original window. The new window has already
+    // been given an offset by the OS, so we shouldn't copy the old bounds.
+    BrowserWindow* new_window = browser->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.
+    browser->window()->Show();
+
+    // The page transition below is only for the purpose of inserting the tab.
+    AddTab(browser, contents_dupe, content::PAGE_TRANSITION_LINK);
+  }
+
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(browser->profile());
+  if (session_service)
+    session_service->TabRestored(contents_dupe, pinned);
+}
+
+bool CanDuplicateTabAt(Browser* browser, int index) {
+  content::NavigationController& nc =
+      GetWebContentsAt(browser, index)->GetController();
+  return nc.GetWebContents() && nc.GetLastCommittedEntry();
+}
+
 void ConvertPopupToTabbedBrowser(Browser* browser) {
   content::RecordAction(UserMetricsAction("ShowAsTab"));
   TabContents* contents =
       browser->tab_strip_model()->DetachTabContentsAt(browser->active_index());
   Browser* b = Browser::Create(browser->profile());
   b->tab_strip_model()->AppendTabContents(contents, true);
   b->window()->Show();
 }
 
 void Exit() {
@@ skipping 409 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.
-    chrome::AddTab(b, view_source_contents, content::PAGE_TRANSITION_LINK);
+    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, chrome::GetActiveTabContents(browser));
+  ViewSource(browser, GetActiveTabContents(browser));
 }
 
 bool CanViewSource(const Browser* browser) {
-  return chrome::GetActiveWebContents(browser)->GetController().CanViewSource();
+  return GetActiveWebContents(browser)->GetController().CanViewSource();
 }
 
 void CreateApplicationShortcuts(Browser* browser) {
   content::RecordAction(UserMetricsAction("CreateShortcut"));
-  chrome::GetActiveTabContents(browser)->extension_tab_helper()->
+  GetActiveTabContents(browser)->extension_tab_helper()->
       CreateApplicationShortcuts();
 }
 
 bool CanCreateApplicationShortcuts(const Browser* browser) {
-  return chrome::GetActiveTabContents(browser)->extension_tab_helper()->
+  return GetActiveTabContents(browser)->extension_tab_helper()->
       CanCreateApplicationShortcuts();
 }
 
 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