Make all browser code use browser::Navigate to open tabs....

chrome/browser/browser.cc

 // Copyright (c) 2010 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"
 
 #if defined(OS_WIN)
 #include <shellapi.h>
 #include <windows.h>
 #endif  // OS_WIN
@@ skipping 14 matching lines @@
 #include "base/utf_string_conversions.h"
 #include "gfx/point.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/autofill/autofill_manager.h"
 #if defined(OS_WIN)
 #include "chrome/browser/autofill/autofill_ie_toolbar_import_win.h"
 #endif  // defined(OS_WIN)
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_list.h"
+#include "chrome/browser/browser_navigator.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/browser_url_handler.h"
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_toggle_action.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/dock_info.h"
 #include "chrome/browser/dom_ui/filebrowse_ui.h"
@@ skipping 558 matching lines @@
 
   ExtensionPrefs::LaunchType launch_type =
       extensions_service->extension_prefs()->GetLaunchType(extension->id());
   UMA_HISTOGRAM_ENUMERATION("Extensions.AppTabLaunchType", launch_type, 100);
   int add_type = TabStripModel::ADD_SELECTED;
   if (launch_type == ExtensionPrefs::LAUNCH_PINNED)
     add_type |= TabStripModel::ADD_PINNED;
 
   // TODO(erikkay): START_PAGE doesn't seem like the right transition in all
   // cases.
-  AddTabWithURLParams params(extension->GetFullLaunchURL(),
-                             PageTransition::START_PAGE);
-  params.add_types = add_type;
+  browser::NavigateParams params(browser, extension->GetFullLaunchURL(),
+                                 PageTransition::START_PAGE);
+  params.tabstrip_add_types = add_type;
 
   // Launch the application in the existing TabContents, if it was supplied.
   if (existing_tab) {
     TabStripModel* model = browser->tabstrip_model();
     int tab_index = model->GetIndexOfTabContents(existing_tab);
 
     existing_tab->OpenURL(extension->GetFullLaunchURL(), existing_tab->GetURL(),
                           CURRENT_TAB, PageTransition::LINK);
-    if (params.add_types & TabStripModel::ADD_PINNED)
+    if (params.tabstrip_add_types & TabStripModel::ADD_PINNED)
       model->SetTabPinned(tab_index, true);
-    if (params.add_types & TabStripModel::ADD_SELECTED)
+    if (params.tabstrip_add_types & TabStripModel::ADD_SELECTED)
       model->SelectTabContentsAt(tab_index, true);
 
     contents = existing_tab;
   } else {
-    contents = browser->AddTabWithURL(&params);
+    params.disposition = NEW_FOREGROUND_TAB;
+    browser::Navigate(&params);
+    contents = params.target_contents;
   }
 
   if (launch_type == ExtensionPrefs::LAUNCH_FULLSCREEN)
     browser->window()->SetFullscreen(true);
 
   return contents;
 }
 
 // static
 void Browser::OpenBookmarkManagerWindow(Profile* profile) {
@@ skipping 267 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Browser, Tab adding/showing functions:
 
 int Browser::GetIndexForInsertionDuringRestore(int relative_index) {
   return (tab_handler_->GetTabStripModel()->insertion_policy() ==
       TabStripModel::INSERT_AFTER) ? tab_count() : relative_index;
 }
 
 TabContents* Browser::AddSelectedTabWithURL(const GURL& url,
                                             PageTransition::Type transition) {
-  AddTabWithURLParams params(url, transition);
-  return AddTabWithURL(&params);
-}
-
-Browser::AddTabWithURLParams::AddTabWithURLParams(
-    const GURL& a_url,
-    PageTransition::Type a_transition)
-    : url(a_url),
-      transition(a_transition),
-      index(-1),
-      add_types(TabStripModel::ADD_SELECTED),
-      instance(NULL),
-      target(NULL) {
-}
-
-Browser::AddTabWithURLParams::~AddTabWithURLParams() {
-}
-
-TabContents* Browser::AddTabWithURL(AddTabWithURLParams* params) {
-  TabContents* contents = NULL;
-  if (CanSupportWindowFeature(FEATURE_TABSTRIP) || tabstrip_model()->empty()) {
-    GURL url_to_load = params->url;
-    if (url_to_load.is_empty())
-      url_to_load = GetHomePage();
-    contents = CreateTabContentsForURL(url_to_load, params->referrer, profile_,
-                                       params->transition, false,
-                                       params->instance);
-    contents->SetExtensionAppById(params->extension_app_id);
-    tab_handler_->GetTabStripModel()->AddTabContents(contents, params->index,
-                                                     params->transition,
-                                                     params->add_types);
-    // TODO(sky): figure out why this is needed. Without it we seem to get
-    // failures in startup tests.
-    // By default, content believes it is not hidden.  When adding contents
-    // in the background, tell it that it's hidden.
-    if ((params->add_types & TabStripModel::ADD_SELECTED) == 0) {
-      // TabStripModel::AddTabContents invokes HideContents if not foreground.
-      contents->WasHidden();
-    }
-    params->target = this;
-  } else {
-    // We're in an app window or a popup window. Find an existing browser to
-    // open this URL in, creating one if none exists.
-    Browser* browser =
-        BrowserList::FindBrowserWithFeature(profile_, FEATURE_TABSTRIP);
-    if (!browser)
-      browser = Browser::Create(profile_);
-    contents = browser->AddTabWithURL(params);
-    DCHECK(params->target);
-  }
-  return contents;
+  browser::NavigateParams params(this, url, transition);
+  params.disposition = NEW_FOREGROUND_TAB;
+  browser::Navigate(&params);
+  return params.target_contents;
 }
 
 TabContents* Browser::AddTab(TabContents* tab_contents,
                              PageTransition::Type type) {
   tab_handler_->GetTabStripModel()->AddTabContents(
       tab_contents, -1, type, TabStripModel::ADD_SELECTED);
   return tab_contents;
 }
 
 void Browser::AddTabContents(TabContents* new_contents,
@@ skipping 91 matching lines @@
                                              WindowOpenDisposition disp) {
   NavigationController& controller =
       GetOrCloneTabForDisposition(disp)->controller();
   if (index < 0 || index >= controller.entry_count())
     return false;
   controller.GoToIndex(index);
   return true;
 }
 
 void Browser::ShowSingletonTab(const GURL& url) {
-  // In case the URL was rewritten by the BrowserURLHandler we need to ensure
-  // that we do not open another URL that will get redirected to the rewritten
-  // URL.
-  GURL rewritten_url(url);
-  bool reverse_on_redirect = false;
-  BrowserURLHandler::RewriteURLIfNecessary(&rewritten_url, profile_,
-                                           &reverse_on_redirect);
-
-  // See if we already have a tab with the given URL and select it if so.
-  TabStripModel* model = tab_handler_->GetTabStripModel();
-  for (int i = 0; i < model->count(); i++) {
-    TabContents* tc = model->GetTabContentsAt(i);
-    if (CompareURLsIgnoreRef(tc->GetURL(), url) ||
-        CompareURLsIgnoreRef(tc->GetURL(), rewritten_url)) {
-      model->SelectTabContentsAt(i, false);
-      return;
-    }
-  }
-
-  // Otherwise, just create a new tab.
-  AddSelectedTabWithURL(url, PageTransition::AUTO_BOOKMARK);
+  browser::NavigateParams params(this, url, PageTransition::AUTO_BOOKMARK);
+  params.disposition = SINGLETON_TAB;
+  params.show_window = true;
+  browser::Navigate(&params);
 }
 
 void Browser::UpdateCommandsForFullscreenMode(bool is_fullscreen) {
 #if !defined(OS_MACOSX)
   const bool show_main_ui = (type() == TYPE_NORMAL) && !is_fullscreen;
 #else
   const bool show_main_ui = (type() == TYPE_NORMAL);
 #endif
 
   bool main_not_fullscreen_or_popup =
@@ skipping 181 matching lines @@
 
 void Browser::OpenCurrentURL() {
   UserMetrics::RecordAction(UserMetricsAction("LoadURL"), profile_);
   LocationBar* location_bar = window_->GetLocationBar();
   WindowOpenDisposition open_disposition =
       location_bar->GetWindowOpenDisposition();
   if (OpenInstant(open_disposition))
     return;
 
   GURL url(WideToUTF8(location_bar->GetInputString()));
-
+  browser::NavigateParams params(this, 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.
-  OpenURLAtIndex(NULL, url, GURL(), open_disposition,
-                 location_bar->GetPageTransition(), -1,
-                 TabStripModel::ADD_FORCE_INDEX |
-                     TabStripModel::ADD_INHERIT_OPENER);
+  params.tabstrip_add_types =
+      TabStripModel::ADD_FORCE_INDEX | TabStripModel::ADD_INHERIT_OPENER;
+  browser::Navigate(&params);
 }
 
 void Browser::Stop() {
   UserMetrics::RecordAction(UserMetricsAction("Stop"), profile_);
   GetSelectedTabContents()->Stop();
 }
 
 void Browser::NewWindow() {
   if (browser_defaults::kAlwaysOpenIncognitoWindow &&
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kIncognito)) {
@@ skipping 496 matching lines @@
   TabStripModel* model = tab_handler_->GetTabStripModel();
   for (int i = 0; i < model->count(); i++) {
     TabContents* tc = model->GetTabContentsAt(i);
     const GURL& tab_url = tc->GetURL();
 
     if (tab_url.scheme() == url.scheme() && tab_url.host() == url.host()) {
       // We found an existing options tab, load the URL in this tab.  (Note:
       // this may cause us to unnecessarily reload the same page.  We can't
       // really detect that unless the options page is permitted to change the
       // URL in the address bar, but security policy doesn't allow that.
-      OpenURLAtIndex(tc, url, GURL(), CURRENT_TAB, PageTransition::GENERATED,
-                     -1, -1);
+      browser::NavigateParams params(this, url, PageTransition::GENERATED);
+      params.source_contents = tc;
+      browser::Navigate(&params);
       model->SelectTabContentsAt(i, false);
       return;
     }
   }
 
   // No options tab found, so create a new one.
   AddSelectedTabWithURL(url, PageTransition::AUTO_BOOKMARK);
 }
 
 void Browser::OpenClearBrowsingDataDialog() {
@@ skipping 69 matching lines @@
   UserMetrics::RecordAction(UserMetricsAction("UpdateChrome"), profile_);
   window_->ShowUpdateChromeDialog();
 }
 
 void Browser::OpenHelpTab() {
   GURL help_url = google_util::AppendGoogleLocaleParam(GURL(kHelpContentUrl));
   AddSelectedTabWithURL(help_url, PageTransition::AUTO_BOOKMARK);
 }
 
 void Browser::OpenThemeGalleryTabAndActivate() {
-  OpenURL(GURL(l10n_util::GetStringUTF8(IDS_THEMES_GALLERY_URL)),
-          GURL(), NEW_FOREGROUND_TAB, PageTransition::LINK);
-  window_->Activate();
+  AddSelectedTabWithURL(GURL(l10n_util::GetStringUTF8(IDS_THEMES_GALLERY_URL)),
+                        PageTransition::LINK);
 }
 
 void Browser::OpenPrivacyDashboardTabAndActivate() {
   OpenURL(GURL(l10n_util::GetStringUTF8(IDS_PRIVACY_DASHBOARD_URL)),
           GURL(), NEW_FOREGROUND_TAB, PageTransition::LINK);
   window_->Activate();
 }
 
 void Browser::OpenAutoFillHelpTabAndActivate() {
-  OpenURL(GURL(l10n_util::GetStringUTF8(IDS_AUTOFILL_HELP_URL)),
-          GURL(), NEW_FOREGROUND_TAB, PageTransition::LINK);
-  window_->Activate();
+  AddSelectedTabWithURL(GURL(l10n_util::GetStringUTF8(IDS_AUTOFILL_HELP_URL)),
+                        PageTransition::LINK);
 }
 
 void Browser::OpenSearchEngineOptionsDialog() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableTabbedOptions)) {
     OpenKeywordEditor();
   } else {
     ShowOptionsWindow(OPTIONS_PAGE_GENERAL, OPTIONS_GROUP_DEFAULT_SEARCH,
                       profile_);
   }
@@ skipping 457 matching lines @@
 
 TabContents* Browser::AddBlankTab(bool foreground) {
   return AddBlankTabAt(-1, foreground);
 }
 
 TabContents* Browser::AddBlankTabAt(int index, bool foreground) {
   // Time new tab page creation time.  We keep track of the timing data in
   // TabContents, but we want to include the time it takes to create the
   // TabContents object too.
   base::TimeTicks new_tab_start_time = base::TimeTicks::Now();
-  AddTabWithURLParams params(GURL(chrome::kChromeUINewTabURL),
-                             PageTransition::TYPED);
-  params.add_types =
+  browser::NavigateParams params(this, GURL(chrome::kChromeUINewTabURL),
+                                 PageTransition::TYPED);
+  params.tabstrip_add_types =
       foreground ? TabStripModel::ADD_SELECTED : TabStripModel::ADD_NONE;
-  params.index = index;
-  TabContents* contents = AddTabWithURL(&params);
-  contents->set_new_tab_start_time(new_tab_start_time);
-  return contents;
+  params.disposition = foreground ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
+  params.tabstrip_index = index;
+  browser::Navigate(&params);
+  params.target_contents->set_new_tab_start_time(new_tab_start_time);
+  return params.target_contents;
 }
 
 Browser* Browser::CreateNewStripWithContents(TabContents* detached_contents,
                                              const gfx::Rect& window_bounds,
                                              const DockInfo& dock_info,
                                              bool maximize) {
   DCHECK(CanSupportWindowFeature(FEATURE_TABSTRIP));
 
   gfx::Rect new_window_bounds = window_bounds;
   if (dock_info.GetNewWindowBounds(&new_window_bounds, &maximize))
@@ skipping 335 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabContentsDelegate implementation:
 
 void Browser::OpenURLFromTab(TabContents* source,
                              const GURL& url,
                              const GURL& referrer,
                              WindowOpenDisposition disposition,
                              PageTransition::Type transition) {
-  OpenURLAtIndex(source, url, referrer, disposition, transition, -1,
-                 TabStripModel::ADD_NONE);
+  browser::NavigateParams params(this, url, transition);
+  params.source_contents = source;
+  params.referrer = referrer;
+  params.disposition = disposition;
+  params.tabstrip_add_types = TabStripModel::ADD_NONE;
+  browser::Navigate(&params);
 }
 
 void Browser::NavigationStateChanged(const TabContents* source,
                                      unsigned changed_flags) {
   // Only update the UI when something visible has changed.
   if (changed_flags)
     ScheduleUIUpdate(source, changed_flags);
 
   // We don't schedule updates to commands since they will only change once per
   // navigation, so we don't have to worry about flickering.
   if (changed_flags & TabContents::INVALIDATE_URL)
     UpdateCommandsForTabState();
 }
 
 void Browser::AddNewContents(TabContents* source,
                              TabContents* new_contents,
                              WindowOpenDisposition disposition,
                              const gfx::Rect& initial_pos,
                              bool user_gesture) {
-  DCHECK(disposition != SAVE_TO_DISK);  // No code for this yet
-  DCHECK(disposition != CURRENT_TAB);  // Can't create a new contents for the
-                                       // current tab.
+  // 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);
 
+  // TODO(beng): This belongs behind the platform-specific View interface.
+  //             That's why it's there.
 #if defined(OS_CHROMEOS)
-    if (disposition == NEW_POPUP) {
-      // If the popup is bigger than a given factor of the screen, then
-      // turn it into a foreground tab (on chrome os only)
-      // Also check for width or height == 0, which would otherwise indicate
-      // a tab sized popup window.
-      GdkScreen* screen = gdk_screen_get_default();
-      int max_width = gdk_screen_get_width(screen) * kPopupMaxWidthFactor;
-      int max_height = gdk_screen_get_height(screen) * kPopupMaxHeightFactor;
-      if (initial_pos.width() > max_width || initial_pos.width() == 0 ||
-          initial_pos.height() > max_height || initial_pos.height() == 0) {
-        disposition = NEW_FOREGROUND_TAB;
-      }
+  if (disposition == NEW_POPUP) {
+    // If the popup is bigger than a given factor of the screen, then
+    // turn it into a foreground tab (on chrome os only)
+    // Also check for width or height == 0, which would otherwise indicate
+    // a tab sized popup window.
+    GdkScreen* screen = gdk_screen_get_default();
+    int max_width = gdk_screen_get_width(screen) * kPopupMaxWidthFactor;
+    int max_height = gdk_screen_get_height(screen) * kPopupMaxHeightFactor;
+    if (initial_pos.width() > max_width || initial_pos.width() == 0 ||
+        initial_pos.height() > max_height || initial_pos.height() == 0) {
+      disposition = NEW_FOREGROUND_TAB;
     }
+  }
 #endif
 
-  // If this is a window with no tabstrip, we can only have one tab so we need
-  // to process this in tabbed browser window.
-  if (!CanSupportWindowFeature(FEATURE_TABSTRIP) &&
-      tab_handler_->GetTabStripModel()->count() > 0 &&
-      disposition != NEW_WINDOW &&
-      disposition != NEW_POPUP) {
-    Browser* b = GetOrCreateTabbedBrowser(profile_);
-    DCHECK(b);
-    PageTransition::Type transition = PageTransition::LINK;
-    // If we were called from an "installed webapp" we want to emulate the code
-    // that is run from browser_init.cc for links from external applications.
-    // This means we need to open the tab with the START PAGE transition.
-    // AddNewContents doesn't support this but the TabStripModel's
-    // AddTabContents method does.
-    if (type_ & TYPE_APP)
-      transition = PageTransition::START_PAGE;
-    b->tabstrip_model()->AddTabContents(
-        new_contents, -1, transition, TabStripModel::ADD_SELECTED);
-    b->window()->Show();
-    return;
-  }
-
-  if (disposition == NEW_POPUP) {
-    Type browser_type;
-    if ((type_ & TYPE_APP) || (source && source->is_app())) {
-      // New app popup, or an app is creating a popup.
-      browser_type = TYPE_APP_POPUP;
-    } else {
-      browser_type = TYPE_POPUP;
-    }
-    Browser* browser = Browser::CreateForPopup(browser_type,
-                                               profile_,
-                                               new_contents,
-                                               initial_pos);
-    browser->window()->Show();
-
-  } else if (disposition == NEW_WINDOW) {
-    Browser* browser = Browser::Create(profile_);
-    browser->AddNewContents(source, new_contents, NEW_FOREGROUND_TAB,
-                            initial_pos, user_gesture);
-    browser->window()->Show();
-  } else if (disposition != SUPPRESS_OPEN) {
-    tab_handler_->GetTabStripModel()->AddTabContents(
-        new_contents, -1, PageTransition::LINK,
-        disposition == NEW_FOREGROUND_TAB ? TabStripModel::ADD_SELECTED :
-                                            TabStripModel::ADD_NONE);
-  }
+    browser::NavigateParams params(this, new_contents);
+    params.source_contents = source;
+    params.disposition = disposition;
+    params.window_bounds = initial_pos;
+    browser::Navigate(&params);
 }
 
 void Browser::ActivateContents(TabContents* contents) {
   tab_handler_->GetTabStripModel()->SelectTabContentsAt(
       tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents), false);
   window_->Activate();
 }
 
 void Browser::DeactivateContents(TabContents* contents) {
   window_->Deactivate();
@@ skipping 1190 matching lines @@
 }
 
 // static
 Browser* Browser::GetOrCreateTabbedBrowser(Profile* profile) {
   Browser* browser = GetTabbedBrowser(profile, false);
   if (!browser)
     browser = Browser::Create(profile);
   return browser;
 }
 
-void Browser::OpenURLAtIndex(TabContents* source,
-                             const GURL& url,
-                             const GURL& referrer,
-                             WindowOpenDisposition disposition,
-                             PageTransition::Type transition,
-                             int index,
-                             int add_types) {
-  // TODO(beng): Move all this code into a separate helper that has unit tests.
-
-  // No code for these yet
-  DCHECK((disposition != NEW_POPUP) && (disposition != SAVE_TO_DISK));
-
-  TabContents* current_tab = source ? source : GetSelectedTabContents();
-  bool source_tab_was_frontmost = (current_tab == GetSelectedTabContents());
-  TabContents* new_contents = NULL;
-
-  // Opening a bookmark counts as a user gesture, so we don't need to avoid
-  // carpet-bombing here.
-  PageTransition::Type baseTransitionType =
-    PageTransition::StripQualifier(transition);
-  if ((baseTransitionType == PageTransition::TYPED ||
-      baseTransitionType == PageTransition::AUTO_BOOKMARK) &&
-      current_tab != NULL) {
-    RenderViewHostDelegate::BrowserIntegration* delegate = current_tab;
-    delegate->OnUserGesture();
-  }
-
-  // If the URL is part of the same web site, then load it in the same
-  // SiteInstance (and thus the same process).  This is an optimization to
-  // reduce process overhead; it is not necessary for compatibility.  (That is,
-  // the new tab will not have script connections to the previous tab, so it
-  // does not need to be part of the same SiteInstance or BrowsingInstance.)
-  // Default to loading in a new SiteInstance and BrowsingInstance.
-  // TODO(creis): should this apply to applications?
-  SiteInstance* instance = NULL;
-  // Don't use this logic when "--process-per-tab" is specified.
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kProcessPerTab)) {
-    if (current_tab) {
-      const GURL& current_url = current_tab->GetURL();
-      if (SiteInstance::IsSameWebSite(profile_, current_url, url))
-        instance = current_tab->GetSiteInstance();
-    }
-  }
-
-  // If this browser doeesn't support tabs, we can only have one tab so a new
-  // tab always goes into a tabbed browser window.
-  if (!CanSupportWindowFeature(FEATURE_TABSTRIP) &&
-      disposition != CURRENT_TAB && disposition != NEW_WINDOW) {
-    // If the disposition is OFF_THE_RECORD we don't want to create a new
-    // browser that will itself create another OTR browser. This will result in
-    // a browser leak (and crash below because no tab is created or selected).
-    if (disposition == OFF_THE_RECORD) {
-      OpenURLOffTheRecord(profile_, url);
-      return;
-    }
-
-    Browser* b = GetOrCreateTabbedBrowser(profile_);
-    DCHECK(b);
-
-    // If we have just created a new browser window, make sure we select the
-    // tab.
-    if (b->tab_count() == 0 && disposition == NEW_BACKGROUND_TAB)
-      disposition = NEW_FOREGROUND_TAB;
-
-    b->OpenURL(url, referrer, disposition, transition);
-    b->window()->Show();
-    return;
-  }
-
-  if (profile_->IsOffTheRecord() && disposition == OFF_THE_RECORD)
-    disposition = NEW_FOREGROUND_TAB;
-
-  if (disposition == SINGLETON_TAB) {
-    ShowSingletonTab(url);
-    return;
-  } else if (disposition == NEW_WINDOW) {
-    Browser* browser = Browser::Create(profile_);
-    AddTabWithURLParams params(url, transition);
-    params.referrer = referrer;
-    params.index = index;
-    params.add_types = TabStripModel::ADD_SELECTED | add_types;
-    params.instance = instance;
-    new_contents = browser->AddTabWithURL(&params);
-    browser->window()->Show();
-  } else if ((disposition == CURRENT_TAB) && current_tab) {
-    tab_handler_->GetTabStripModel()->TabNavigating(current_tab, transition);
-
-    bool user_initiated = (PageTransition::StripQualifier(transition) ==
-                           PageTransition::AUTO_BOOKMARK);
-
-    if (user_initiated && source_tab_was_frontmost &&
-        window_->GetLocationBar()) {
-      // Forcibly reset the location bar if the url is going to change in the
-      // current tab, since otherwise it won't discard any ongoing user edits,
-      // since it doesn't realize this is a user-initiated action.
-      window_->GetLocationBar()->Revert();
-    }
-
-    current_tab->controller().LoadURL(url, referrer, transition);
-    new_contents = current_tab;
-    if (GetStatusBubble())
-      GetStatusBubble()->Hide();
-
-    // Update the location bar. This is synchronous. We specifically don't
-    // update the load state since the load hasn't started yet and updating it
-    // will put it out of sync with the actual state like whether we're
-    // displaying a favicon, which controls the throbber. If we updated it here,
-    // the throbber will show the default favicon for a split second when
-    // navigating away from the new tab page.
-    ScheduleUIUpdate(current_tab, TabContents::INVALIDATE_URL);
-  } else if (disposition == OFF_THE_RECORD) {
-    OpenURLOffTheRecord(profile_, url);
-    return;
-  } else if (disposition != SUPPRESS_OPEN) {
-    if (disposition != NEW_BACKGROUND_TAB)
-      add_types |= TabStripModel::ADD_SELECTED;
-    AddTabWithURLParams params(url, transition);
-    params.referrer = referrer;
-    params.index = index;
-    params.add_types = add_types;
-    params.instance = instance;
-    new_contents = AddTabWithURL(&params);
-  }
-
-  if (disposition != NEW_BACKGROUND_TAB && source_tab_was_frontmost &&
-      new_contents) {
-    // Give the focus to the newly navigated tab, if the source tab was
-    // front-most.
-    new_contents->Focus();
-  }
-}
-
 void Browser::FindInPage(bool find_next, bool forward_direction) {
   ShowFindBar();
   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
     GetSelectedTabContents()->StartFinding(find_text,
                                            forward_direction,
@@ skipping 92 matching lines @@
   NOTREACHED();
   return false;
 }
 
 void Browser::CreateInstantIfNecessary() {
   if (type() == TYPE_NORMAL && InstantController::IsEnabled(profile()) &&
       !profile()->IsOffTheRecord()) {
     instant_.reset(new InstantController(this));
   }
 }