Fix pinned tab link navigations.

chrome/browser/tabs/tab_strip_model.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/tabs/tab_strip_model.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/tabs/tab_strip_model_order_controller.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
@@ skipping 137 matching lines @@
 }
 
 TabContents* TabStripModel::DetachTabContentsAt(int index) {
   if (contents_data_.empty())
     return NULL;
 
   DCHECK(ContainsIndex(index));
   TabContents* removed_contents = GetContentsAt(index);
   int next_selected_index =
       order_controller_->DetermineNewSelectedIndex(index, true);
-  delete contents_data_.at(index);
+  delete contents_data_[index];
   contents_data_.erase(contents_data_.begin() + index);
   next_selected_index = IndexOfNextNonPhantomTab(next_selected_index, -1);
   if (!HasNonPhantomTabs())
     closing_all_ = true;
   TabStripModelObservers::Iterator iter(observers_);
   while (TabStripModelObserver* obs = iter.GetNext()) {
     obs->TabDetachedAt(removed_contents, index);
     if (!HasNonPhantomTabs())
       obs->TabStripEmpty();
   }
@@ skipping 91 matching lines @@
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter) {
     if ((*iter)->contents->is_loading())
       return true;
   }
   return false;
 }
 
 NavigationController* TabStripModel::GetOpenerOfTabContentsAt(int index) {
   DCHECK(ContainsIndex(index));
-  return contents_data_.at(index)->opener;
+  return contents_data_[index]->opener;
 }
 
 int TabStripModel::GetIndexOfNextTabContentsOpenedBy(
     const NavigationController* opener, int start_index, bool use_group) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   // Check tabs after start_index first.
   for (int i = start_index + 1; i < count(); ++i) {
     if (OpenerMatches(contents_data_[i], opener, use_group) &&
@@ skipping 71 matching lines @@
   // Forget all opener memories so we don't do anything weird with tab
   // re-selection ordering.
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter)
     (*iter)->ForgetOpener();
 }
 
 void TabStripModel::ForgetGroup(TabContents* contents) {
   int index = GetIndexOfTabContents(contents);
   DCHECK(ContainsIndex(index));
-  contents_data_.at(index)->SetGroup(NULL);
-  contents_data_.at(index)->ForgetOpener();
+  contents_data_[index]->SetGroup(NULL);
+  contents_data_[index]->ForgetOpener();
 }
 
 bool TabStripModel::ShouldResetGroupOnSelect(TabContents* contents) const {
   int index = GetIndexOfTabContents(contents);
   DCHECK(ContainsIndex(index));
-  return contents_data_.at(index)->reset_group_on_select;
+  return contents_data_[index]->reset_group_on_select;
 }
 
 void TabStripModel::SetTabBlocked(int index, bool blocked) {
   DCHECK(ContainsIndex(index));
   if (contents_data_[index]->blocked == blocked)
     return;
   contents_data_[index]->blocked = blocked;
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabBlockedStateChanged(contents_data_[index]->contents,
       index));
 }
 
 void TabStripModel::SetTabPinned(int index, bool pinned) {
   DCHECK(ContainsIndex(index));
   if (contents_data_[index]->pinned == pinned)
     return;
 
+  // Reroute toplevel requests to the browser if the tab is pinned. This allows
+  // us to rewrite the WindowOpenDisposition in certain cases.
+  TabContents* contents = contents_data_[index]->contents;
+  contents->GetMutableRendererPrefs()->browser_handles_top_level_requests =
+      pinned;
+  if (contents->render_view_host())
+    contents->render_view_host()->SyncRendererPrefs();
+
   if (IsAppTab(index)) {
     // Changing the pinned state of an app tab doesn't effect it's mini-tab
     // status.
     contents_data_[index]->pinned = pinned;
   } else {
     // The tab is not an app tab, it's position may have to change as the
     // mini-tab state is changing.
     int non_mini_tab_index = IndexOfFirstNonMiniTab();
     contents_data_[index]->pinned = pinned;
     if (pinned && index != non_mini_tab_index) {
       MoveTabContentsAtImpl(index, non_mini_tab_index, false);
       return;  // Don't send TabPinnedStateChanged notification.
     } else if (!pinned && index + 1 != non_mini_tab_index) {
       MoveTabContentsAtImpl(index, non_mini_tab_index - 1, false);
       return;  // Don't send TabPinnedStateChanged notification.
     }
 
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                      TabMiniStateChanged(contents_data_[index]->contents,
-                                          index));
+                      TabMiniStateChanged(contents, index));
   }
 
   // else: the tab was at the boundary and it's position doesn't need to
   // change.
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabPinnedStateChanged(contents_data_[index]->contents,
-                                          index));
+                    TabPinnedStateChanged(contents, index));
 }
 
 bool TabStripModel::IsTabPinned(int index) const {
   return contents_data_[index]->pinned;
 }
 
 bool TabStripModel::IsMiniTab(int index) const {
   return IsTabPinned(index) || IsAppTab(index);
 }
 
@@ skipping 68 matching lines @@
     // creates a New Tab (e.g. Ctrl+T, or clicks the New Tab button), or types
     // in the address bar and presses Alt+Enter. This allows for opening a new
     // Tab to quickly look up something. When this Tab is closed, the old one
     // is re-selected, not the next-adjacent.
     inherit_group = true;
   }
   InsertTabContentsAt(index, contents, foreground, inherit_group);
   // Reset the index, just in case insert ended up moving it on us.
   index = GetIndexOfTabContents(contents);
   if (inherit_group && transition == PageTransition::TYPED)
-    contents_data_.at(index)->reset_group_on_select = true;
+    contents_data_[index]->reset_group_on_select = true;
 
   // Ensure that the new TabContentsView begins at the same size as the
   // previous TabContentsView if it existed.  Otherwise, the initial WebKit
   // layout will be performed based on a width of 0 pixels, causing a
   // very long, narrow, inaccurate layout.  Because some scripts on pages (as
   // well as WebKit's anchor link location calculation) are run on the
   // initial layout and not recalculated later, we need to ensure the first
   // layout is performed with sane view dimensions even when we're opening a
   // new background tab.
   if (TabContents* old_contents = GetSelectedTabContents()) {
@@ skipping 398 matching lines @@
     delegate_->CreateHistoricalTab(contents);
 
   // Deleting the TabContents will call back to us via NotificationObserver
   // and detach it.
   delete contents;
 }
 
 TabContents* TabStripModel::GetContentsAt(int index) const {
   CHECK(ContainsIndex(index)) <<
       "Failed to find: " << index << " in: " << count() << " entries.";
-  return contents_data_.at(index)->contents;
+  return contents_data_[index]->contents;
 }
 
 void TabStripModel::ChangeSelectedContentsFrom(
     TabContents* old_contents, int to_index, bool user_gesture) {
   DCHECK(ContainsIndex(to_index));
   TabContents* new_contents = GetContentsAt(to_index);
   if (old_contents == new_contents)
     return;
 
   TabContents* last_selected_contents = old_contents;
   if (last_selected_contents) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       TabDeselectedAt(last_selected_contents, selected_index_));
   }
 
   selected_index_ = to_index;
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabSelectedAt(last_selected_contents, new_contents, selected_index_,
                     user_gesture));
 }
 
 void TabStripModel::SetOpenerForContents(TabContents* contents,
                                     TabContents* opener) {
   int index = GetIndexOfTabContents(contents);
-  contents_data_.at(index)->opener = &opener->controller();
+  contents_data_[index]->opener = &opener->controller();
 }
 
 void TabStripModel::SelectRelativeTab(bool next) {
   // This may happen during automated testing or if a user somehow buffers
   // many key accelerators.
   if (contents_data_.empty())
     return;
 
   // Skip pinned-app-phantom tabs when iterating.
   int index = selected_index_;
@@ skipping 67 matching lines @@
     SelectTabContentsAt(new_selected_index, true);
   }
 
   if (!HasNonPhantomTabs())
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_, TabStripEmpty());
 }
 
 
 void TabStripModel::MoveTabContentsAtImpl(int index, int to_position,
                                           bool select_after_move) {
-  TabContentsData* moved_data = contents_data_.at(index);
+  TabContentsData* moved_data = contents_data_[index];
   contents_data_.erase(contents_data_.begin() + index);
   contents_data_.insert(contents_data_.begin() + to_position, moved_data);
 
   // if !select_after_move, keep the same tab selected as was selected before.
   if (select_after_move || index == selected_index_) {
     selected_index_ = to_position;
   } else if (index < selected_index_ && to_position >= selected_index_) {
     selected_index_--;
   } else if (index > selected_index_ && to_position <= selected_index_) {
     selected_index_++;
   }
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabMoved(moved_data->contents, index, to_position));
 }
 
 // static
 bool TabStripModel::OpenerMatches(const TabContentsData* data,
                                   const NavigationController* opener,
                                   bool use_group) {
   return data->opener == opener || (use_group && data->group == opener);
 }