Issue 358: Can't open a new tab by middle-clicking home button...

chrome/browser/browser.cc

 // Copyright (c) 2006-2008 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.h"
 
 #include "base/command_line.h"
 #include "base/idle_timer.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 534 matching lines @@
     }
   }
 
   // Otherwise, just create a new tab.
   AddTabWithURL(url, GURL(), PageTransition::AUTO_BOOKMARK, true, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Assorted browser commands:
 
-void Browser::GoBack() {
+void Browser::GoBack(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(L"Back", profile_);
 
   // If we are showing an interstitial, just hide it.
   TabContents* current_tab = GetSelectedTabContents();
   WebContents* web_contents = current_tab->AsWebContents();
   if (web_contents && web_contents->interstitial_page()) {
     // The GoBack() case is a special case when an interstitial is shown because
     // the "previous" page is still available, just hidden by the interstitial.
     // We treat the back as a "Don't proceed", this hides the interstitial and
     // reveals the previous page.
     web_contents->interstitial_page()->DontProceed();
     return;
   }
-  if (current_tab->controller()->CanGoBack())
-    current_tab->controller()->GoBack();
+
+  if (current_tab->controller()->CanGoBack()) {
+    NavigationController* controller = 0;
+    if (disposition == NEW_FOREGROUND_TAB || disposition == NEW_BACKGROUND_TAB){
+      controller = GetSelectedTabContents()->controller()->Clone();
+      tabstrip_model_.AddTabContents(
+          controller->active_contents(), -1,
+          PageTransition::LINK, disposition == NEW_FOREGROUND_TAB);
+    } else {
+      // Default disposition is CURRENT_TAB.
+      controller = current_tab->controller();
+    }
+    controller->GoBack();
+  }
 }
 
-void Browser::GoForward() {
+void Browser::GoForward(WindowOpenDisposition disp) {
   UserMetrics::RecordAction(L"Forward", profile_);
-  if (GetSelectedTabContents()->controller()->CanGoForward())
-    GetSelectedTabContents()->controller()->GoForward();
+  if (GetSelectedTabContents()->controller()->CanGoForward()) {
+    NavigationController* controller = 0;
+    if (disp == NEW_FOREGROUND_TAB || disp == NEW_BACKGROUND_TAB) {
+      controller = GetSelectedTabContents()->controller()->Clone();
+      tabstrip_model_.AddTabContents(
+          controller->active_contents(), -1,
+          PageTransition::LINK, disp == NEW_FOREGROUND_TAB);
+    } else {
+      // Default disposition is CURRENT_TAB.
+      controller = GetSelectedTabContents()->controller();
+    }
+    controller->GoForward();
+  }
 }
 
 void Browser::Reload() {
   UserMetrics::RecordAction(L"Reload", profile_);
 
   // If we are showing an interstitial, treat this as an OpenURL.
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab) {
     WebContents* web_contents = current_tab->AsWebContents();
     if (web_contents && web_contents->showing_interstitial_page()) {
       NavigationEntry* entry = current_tab->controller()->GetActiveEntry();
       DCHECK(entry);  // Should exist if interstitial is showing.
       OpenURL(entry->url(), GURL(), CURRENT_TAB, PageTransition::RELOAD);
       return;
     }
   }
 
   if (current_tab) {
     // As this is caused by a user action, give the focus to the page.
     current_tab->Focus();
     current_tab->controller()->Reload(true);
   }
 }
 
-void Browser::Home() {
+void Browser::Home(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(L"Home", profile_);
-  GURL homepage_url = GetHomePage();
-  GetSelectedTabContents()->controller()->LoadURL(
-      homepage_url, GURL(), PageTransition::AUTO_BOOKMARK);
+  OpenURL(GetHomePage(), GURL(), disposition, PageTransition::AUTO_BOOKMARK);
 }
 
 void Browser::OpenCurrentURL() {
   UserMetrics::RecordAction(L"LoadURL", profile_);
   LocationBar* location_bar = window_->GetLocationBar();
   OpenURL(GURL(WideToUTF8(location_bar->GetInputString())), GURL(),
                location_bar->GetWindowOpenDisposition(),
                location_bar->GetPageTransition());
 }
 
-void Browser::Go() {
+void Browser::Go(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(L"Go", profile_);
-  window_->GetLocationBar()->AcceptInput();
+  window_->GetLocationBar()->AcceptInputWithDisposition(disposition);
 }
 
 void Browser::Stop() {
   UserMetrics::RecordAction(L"Stop", profile_);
   GetSelectedTabContents()->Stop();
 }
 
 void Browser::NewWindow() {
   UserMetrics::RecordAction(L"NewWindow", profile_);
   Browser::OpenEmptyWindow(profile_->GetOriginalProfile());
@@ skipping 467 matching lines @@
     if (index != TabStripModel::kNoTab) {
       if (index_result)
         *index_result = index;
       return *it;
     }
   }
 
   return NULL;
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// Browser, CommandUpdater::CommandUpdaterDelegate implementation:
-
-void Browser::ExecuteCommand(int id) {
+void Browser::ExecuteCommandWithDisposition(
+  int id, WindowOpenDisposition disposition) {
   // No commands are enabled if there is not yet any selected tab.
   // TODO(pkasting): It seems like we should not need this, because either
   // most/all commands should not have been enabled yet anyway or the ones that
   // are enabled should be global, or safe themselves against having no selected
   // tab.  However, Ben says he tried removing this before and got lots of
   // crashes, e.g. from Windows sending WM_COMMANDs at random times during
   // window construction.  This probably could use closer examination someday.
   if (!GetSelectedTabContents())
     return;
 
   DCHECK(command_updater_.IsCommandEnabled(id)) << "Invalid/disabled command";
 
   // The order of commands in this switch statement must match the function
   // declaration order in browser.h!
   switch (id) {
     // Navigation commands
-    case IDC_BACK:                  GoBack();                      break;
-    case IDC_FORWARD:               GoForward();                   break;
+    case IDC_BACK:                  GoBack(disposition);           break;
+    case IDC_FORWARD:               GoForward(disposition);        break;
     case IDC_RELOAD:                Reload();                      break;
-    case IDC_HOME:                  Home();                        break;
+    case IDC_HOME:                  Home(disposition);             break;
     case IDC_OPEN_CURRENT_URL:      OpenCurrentURL();              break;
-    case IDC_GO:                    Go();                          break;
+    case IDC_GO:                    Go(disposition);               break;
     case IDC_STOP:                  Stop();                        break;
 
      // Window management commands
     case IDC_NEW_WINDOW:            NewWindow();                   break;
     case IDC_NEW_INCOGNITO_WINDOW:  NewIncognitoWindow();          break;
     case IDC_NEW_WINDOW_PROFILE_0:
     case IDC_NEW_WINDOW_PROFILE_1:
     case IDC_NEW_WINDOW_PROFILE_2:
     case IDC_NEW_WINDOW_PROFILE_3:
     case IDC_NEW_WINDOW_PROFILE_4:
@@ skipping 134 matching lines @@
 #endif
     case IDC_HELP_PAGE:             OpenHelpTab();                 break;
 
     default:
       LOG(WARNING) << "Received Unimplemented Command: " << id;
       break;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// Browser, CommandUpdater::CommandUpdaterDelegate implementation:
+
+void Browser::ExecuteCommand(int id) {
+  ExecuteCommandWithDisposition(id, CURRENT_TAB);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelDelegate implementation:
 
 GURL Browser::GetBlankTabURL() const {
   return GURL(chrome::kChromeUINewTabURL);
 }
 
 void Browser::CreateNewStripWithContents(TabContents* detached_contents,
                                          const gfx::Rect& window_bounds,
                                          const DockInfo& dock_info) {
   DCHECK(type_ == TYPE_NORMAL);
@@ skipping 1199 matching lines @@
 
   // We need to register the window position pref.
   std::wstring window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append(L"_");
   window_pref.append(app_name);
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
 
   prefs->RegisterDictionaryPref(window_pref.c_str());
 }