Multi-tab selection for Linux.

chrome/browser/tabs/tab_strip_model.cc

 // Copyright (c) 2011 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 <map>
 
 #include "base/command_line.h"
@@ skipping 226 matching lines @@
                                    false);
       }
     }
   }
   return removed_contents;
 }
 
 void TabStripModel::ActivateTabAt(int index, bool user_gesture) {
   DCHECK(ContainsIndex(index));
   bool had_multi = selection_model_.selected_indices().size() > 1;
+  std::vector<int> old_selected_indices(selection_model().selected_indices());
   TabContentsWrapper* old_contents =
       (active_index() == TabStripSelectionModel::kUnselectedIndex) ?
       NULL : GetSelectedTabContents();
   selection_model_.SetSelectedIndex(index);
   TabContentsWrapper* new_contents = GetContentsAt(index);
   if (old_contents != new_contents && old_contents) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       TabDeselected(old_contents));
   }
   if (old_contents != new_contents || had_multi) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       ActiveTabChanged(old_contents, new_contents,
                                        active_index(), user_gesture));
+    NotifySelectionChanged(old_selected_indices);
   }
 }
 
 void TabStripModel::MoveTabContentsAt(int index,
                                       int to_position,
                                       bool select_after_move) {
   DCHECK(ContainsIndex(index));
   if (index == to_position)
     return;
 
@@ skipping 293 matching lines @@
 }
 
 int TabStripModel::ConstrainInsertionIndex(int index, bool mini_tab) {
   return mini_tab ? std::min(std::max(0, index), IndexOfFirstNonMiniTab()) :
       std::min(count(), std::max(index, IndexOfFirstNonMiniTab()));
 }
 
 void TabStripModel::ExtendSelectionTo(int index) {
   DCHECK(ContainsIndex(index));
   int old_active = active_index();
+  std::vector<int> old_selected_indices(selection_model().selected_indices());
   selection_model_.SetSelectionFromAnchorTo(index);
   // This may not have resulted in a change, but we assume it did.
   NotifyActiveTabChanged(old_active);
+  NotifySelectionChanged(old_selected_indices);
 }
 
 void TabStripModel::ToggleSelectionAt(int index) {
   DCHECK(ContainsIndex(index));
   int old_active = active_index();
+  std::vector<int> old_selected_indices(selection_model().selected_indices());
   if (selection_model_.IsSelected(index)) {
     if (selection_model_.size() == 1) {
       // One tab must be selected and this tab is currently selected so we can't
       // unselect it.
       return;
     }
     selection_model_.RemoveIndexFromSelection(index);
     selection_model_.set_anchor(index);
     if (selection_model_.active() == TabStripSelectionModel::kUnselectedIndex)
       selection_model_.set_active(selection_model_.selected_indices()[0]);
   } else {
     selection_model_.AddIndexToSelection(index);
     selection_model_.set_anchor(index);
     selection_model_.set_active(index);
   }
   NotifyActiveTabChanged(old_active);
+  NotifySelectionChanged(old_selected_indices);
 }
 
 void TabStripModel::AddSelectionFromAnchorTo(int index) {
   int old_active = active_index();
+  std::vector<int> old_selected_indices(selection_model().selected_indices());
   selection_model_.AddSelectionFromAnchorTo(index);
   NotifyActiveTabChanged(old_active);
+  NotifySelectionChanged(old_selected_indices);
 }
 
 bool TabStripModel::IsTabSelected(int index) const {
   DCHECK(ContainsIndex(index));
   return selection_model_.IsSelected(index);
 }
 
 void TabStripModel::SetSelectionFromModel(
     const TabStripSelectionModel& source) {
   DCHECK_NE(TabStripSelectionModel::kUnselectedIndex, source.active());
   int old_active_index = active_index();
+  std::vector<int> old_selected_indices(selection_model().selected_indices());
   selection_model_.Copy(source);
   // This may not have resulted in a change, but we assume it did.
   NotifyActiveTabChanged(old_active_index);
+  NotifySelectionChanged(old_selected_indices);
 }
 
 void TabStripModel::AddTabContents(TabContentsWrapper* contents,
                                    int index,
                                    PageTransition::Type transition,
                                    int add_types) {
   // If the newly-opened tab is part of the same task as the parent tab, we want
   // to inherit the parent's "group" attribute, so that if this tab is then
   // closed we'll jump back to the parent tab.
   bool inherit_group = (add_types & ADD_INHERIT_GROUP) == ADD_INHERIT_GROUP;
@@ skipping 602 matching lines @@
   TabContentsWrapper* old_tab =
       old_active_index == TabStripSelectionModel::kUnselectedIndex ?
       NULL : GetTabContentsAt(old_active_index);
   TabContentsWrapper* new_tab =
       active_index() == TabStripSelectionModel::kUnselectedIndex ?
       NULL : GetTabContentsAt(active_index());
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     ActiveTabChanged(old_tab, new_tab, active_index(), true));
 }
 
+void TabStripModel::NotifySelectionChanged(
+    const std::vector<int>& old_selected_indices) {
+  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
+                    TabSelectionChanged(old_selected_indices,
+                                        selection_model().selected_indices()));
+}
+
 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;
 
   int index = active_index();
   int delta = next ? 1 : -1;
   index = (index + count() + delta) % count();
   ActivateTabAt(index, true);
@@ skipping 62 matching lines @@
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
     const NavigationController* tab) {
   for (TabContentsDataVector::const_iterator i = contents_data_.begin();
        i != contents_data_.end(); ++i) {
     if ((*i)->group == tab)
       (*i)->group = NULL;
     if ((*i)->opener == tab)
       (*i)->opener = NULL;
   }
 }