Further refine the pinned tab navigation algorithm.

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 1192 matching lines @@
     if (extension && selected_contents &&
         selected_contents->GetURL().GetOrigin() ==
             GURL(chrome::kChromeUINewTabURL).GetOrigin()) {
       // If the |url| is within an app's web extent and it was typed into the
       // omnibox of an NTP page, interpret as an app launch and close the NTP
       // tab.
       Browser::OpenApplication(profile(), extension,
           extension->launch_container());
       CloseTabContents(selected_contents);
       return;
-    } else if (tabstrip_model()->IsTabPinned(selected_index())) {
-      // To make pinned tabs feel more permanent any requests from the omnibox
-      // to open a url in the current tab with a host different from the current
-      // host of the pinned tab result in creating a new tab. We allow changes
-      // to the path so that the user can trigger reloads or fix up parts of the
-      // url without spawning a new tab.
-      if (!selected_contents ||
-          url.host() != selected_contents->GetURL().host())
-        open_disposition = NEW_FOREGROUND_TAB;
     }
   }
+
   OpenURLAtIndex(NULL, url, GURL(),
                  open_disposition,
                  location_bar->GetPageTransition(), -1, true);
 }
 
 void Browser::Stop() {
   UserMetrics::RecordAction(UserMetricsAction("Stop"), profile_);
   GetSelectedTabContents()->Stop();
 }
 
@@ skipping 2329 matching lines @@
   }
 
   // If our source tab is an app tab, don't allow normal web content to
   // overwrite it.
   if (source->extension_app() && *disposition == CURRENT_TAB)
     *disposition = NEW_FOREGROUND_TAB;
 
   return false;
 }
 
+// static
+WindowOpenDisposition Browser::AdjustWindowOpenDispositionForTab(
+    bool is_pinned,
+    const GURL& url,
+    const GURL& referrer,
+    PageTransition::Type transition,
+    WindowOpenDisposition original_disposition) {
+  if (!is_pinned ||
+      original_disposition != CURRENT_TAB ||
+      (transition != PageTransition::AUTO_BOOKMARK &&
+      transition != PageTransition::LINK)) {
+    return original_disposition;
+  }
+
+  bool url_is_http_or_https =
+       url.SchemeIs(chrome::kHttpScheme) ||
+       url.SchemeIs(chrome::kHttpsScheme);
+  bool referrer_is_http_or_https =
+       referrer.SchemeIs(chrome::kHttpScheme) ||
+       referrer.SchemeIs(chrome::kHttpsScheme);
+  bool scheme_matches =
+      (url.scheme() == referrer.scheme()) ||
+      (url_is_http_or_https && referrer_is_http_or_https);
+
+  // If the host and scheme are the same, then we allow the link to open in
+  // the current tab, to make the page feel more web-appy.
+  if (url.host() == referrer.host() && scheme_matches)
+    return original_disposition;
+
+  return NEW_FOREGROUND_TAB;
+}
+
 void Browser::OpenURLAtIndex(TabContents* source,
                              const GURL& url,
                              const GURL& referrer,
                              WindowOpenDisposition disposition,
                              PageTransition::Type transition,
                              int index,
                              bool force_index) {
   // 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 (current_tab && IsPinned(current_tab) &&
-      transition == PageTransition::AUTO_BOOKMARK &&
-      disposition == CURRENT_TAB) {
-    disposition = NEW_FOREGROUND_TAB;
-  }
+  transition = AdjustWindowOpenDispositionForTab(
+      current_tab && IsPinned(current_tab),
+      url,
+      referrer,
+      transition,
+      disposition);
 
   if (HandleCrossAppNavigation(current_tab, url, referrer, &disposition,
                                transition)) {
     // If the source tab was brand new, we can be left with an empty tab which
     // looks ugly. Close it. It is still kinda ugly to have a tab flash visible
     // for a second, then disappear. But I think it is better than having a
     // dead tab just hang around.
     if (source->controller().entry_count() == 0)
       CloseTabContents(source);
     return;
@@ skipping 242 matching lines @@
 }
 
 bool Browser::IsPinned(TabContents* source) {
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED() << "IsPinned called for tab not in our strip";
     return false;
   }
   return tabstrip_model_.IsTabPinned(index);
 }