Added tab notification to accessibility_event_router_views.

chrome/browser/ui/views/tabs/tab_strip.cc

 // Copyright (c) 2012 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/ui/views/tabs/tab_strip.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 586 matching lines @@
   views::Widget* widget = GetWidget();
   return browser_defaults::kSizeTabButtonToTopOfTabStrip ||
       (widget && (widget->IsMaximized() || widget->IsFullscreen()));
 }
 
 void TabStrip::StartHighlight(int model_index) {
   tab_at(model_index)->StartPulse();
 }
 
 void TabStrip::StopAllHighlighting() {
-  for (int i = 0; i < tab_count(); ++i)
+  for (int i = 0; i < GetTabCount(); ++i)
     tab_at(i)->StopPulse();
 }
 
 void TabStrip::AddTabAt(int model_index,
                         const TabRendererData& data,
                         bool is_active) {
   // Stop dragging when a new tab is added and dragging a window. Doing
   // otherwise results in a confusing state if the user attempts to reattach. We
   // could allow this and make TabDragController update itself during the add,
   // but this comes up infrequently enough that it's not work the complexity.
@@ skipping 12 matching lines @@
     int add_types = 0;
     if (data.mini)
       add_types |= StackedTabStripLayout::kAddTypeMini;
     if (is_active)
       add_types |= StackedTabStripLayout::kAddTypeActive;
     touch_layout_->AddTab(model_index, add_types, GetStartXForNormalTabs());
   }
 
   // Don't animate the first tab, it looks weird, and don't animate anything
   // if the containing window isn't visible yet.
-  if (tab_count() > 1 && GetWidget() && GetWidget()->IsVisible())
+  if (GetTabCount() > 1 && GetWidget() && GetWidget()->IsVisible())
     StartInsertTabAnimation(model_index);
   else
     DoLayout();
 
   SwapLayoutIfNecessary();
 
   FOR_EACH_OBSERVER(TabStripObserver, observers_,
                     TabStripAddedTabAt(this, model_index));
 }
 
@@ skipping 198 matching lines @@
   tab_at(new_selection.active())->NotifyAccessibilityEvent(
       ui::AX_EVENT_SELECTION, true);
 }
 
 void TabStrip::TabTitleChangedNotLoading(int model_index) {
   Tab* tab = tab_at(model_index);
   if (tab->data().mini && !tab->IsActive())
     tab->StartMiniTabTitleAnimation();
 }
 
-int TabStrip::GetModelIndexOfTab(const Tab* tab) const {
-  return tabs_.GetIndexOfView(tab);
-}
-
 int TabStrip::GetModelCount() const {
   return controller_->GetCount();
 }
 
 bool TabStrip::IsValidModelIndex(int model_index) const {
   return controller_->IsValidIndex(model_index);
 }
 
 bool TabStrip::IsDragSessionActive() const {
   return drag_controller_.get() != NULL;
 }
 
 bool TabStrip::IsActiveDropTarget() const {
-  for (int i = 0; i < tab_count(); ++i) {
+  for (int i = 0; i < GetTabCount(); ++i) {
     Tab* tab = tab_at(i);
     if (tab->dragging())
       return true;
   }
   return false;
 }
 
 bool TabStrip::IsTabStripEditable() const {
   return !IsDragSessionActive() && !IsActiveDropTarget();
 }
@@ skipping 29 matching lines @@
       !newtab_button_->HitTestRect(rect_in_newtab_coords))
     return true;
 
   // All other regions, including the new Tab button, should be considered part
   // of the containing Window's client area so that regular events can be
   // processed for them.
   return false;
 }
 
 void TabStrip::SetBackgroundOffset(const gfx::Point& offset) {
-  for (int i = 0; i < tab_count(); ++i)
+  for (int i = 0; i < GetTabCount(); ++i)
     tab_at(i)->set_background_offset(offset);
   newtab_button_->set_background_offset(offset);
 }
 
 void TabStrip::SetImmersiveStyle(bool enable) {
   if (immersive_style_ == enable)
     return;
   immersive_style_ = enable;
 }
 
@@ skipping 112 matching lines @@
   if (!IsValidModelIndex(model_index)) {
     CHECK(false);
     return;
   }
   Tabs tabs;
   int size_to_selected = 0;
   int x = tab->GetMirroredXInView(event.x());
   int y = event.y();
   // Build the set of selected tabs to drag and calculate the offset from the
   // first selected tab.
-  for (int i = 0; i < tab_count(); ++i) {
+  for (int i = 0; i < GetTabCount(); ++i) {
     Tab* other_tab = tab_at(i);
     if (IsTabSelected(other_tab)) {
       tabs.push_back(other_tab);
       if (other_tab == tab) {
         size_to_selected = GetSizeNeededForTabs(tabs);
         x = size_to_selected - tab->width() + x;
       }
     }
   }
   DCHECK(!tabs.empty());
@@ skipping 71 matching lines @@
   // Only touch layout needs to restrict the clip.
   if (!touch_layout_ && !IsStackingDraggedTabs())
     return true;
 
   int index = GetModelIndexOfTab(tab);
   if (index == -1)
     return true;  // Tab is closing, paint it all.
 
   int active_index = IsStackingDraggedTabs() ?
       controller_->GetActiveIndex() : touch_layout_->active_index();
-  if (active_index == tab_count())
+  if (active_index == GetTabCount())
     active_index--;
 
   if (index < active_index) {
     if (tab_at(index)->x() == tab_at(index + 1)->x())
       return false;
 
     if (tab_at(index)->x() > tab_at(index + 1)->x())
       return true;  // Can happen during dragging.
 
     clip->SetRect(
@@ skipping 56 matching lines @@
 
   const chrome::HostDesktopType host_desktop_type =
       chrome::GetHostDesktopTypeForNativeView(GetWidget()->GetNativeView());
   const int inactive_tab_alpha =
       (host_desktop_type == chrome::HOST_DESKTOP_TYPE_ASH) ?
       kInactiveTabAndNewTabButtonAlphaAsh : kInactiveTabAndNewTabButtonAlpha;
 
   if (inactive_tab_alpha < 255)
     canvas->SaveLayerAlpha(inactive_tab_alpha);
 
-  PaintClosingTabs(canvas, tab_count(), cull_set);
+  PaintClosingTabs(canvas, GetTabCount(), cull_set);
 
-  for (int i = tab_count() - 1; i >= 0; --i) {
+  for (int i = GetTabCount() - 1; i >= 0; --i) {
     Tab* tab = tab_at(i);
     if (tab->IsSelected())
       selected_tab_count++;
     if (tab->dragging() && !stacked_layout_) {
       is_dragging = true;
       if (tab->IsActive()) {
         active_tab = tab;
         active_tab_index = i;
       } else {
         tabs_dragging.push_back(tab);
@@ skipping 12 matching lines @@
     PaintClosingTabs(canvas, i, cull_set);
   }
 
   // Draw from the left and then the right if we're in touch mode.
   if (stacked_layout_ && active_tab_index >= 0) {
     for (int i = 0; i < active_tab_index; ++i) {
       Tab* tab = tab_at(i);
       tab->Paint(canvas, cull_set);
     }
 
-    for (int i = tab_count() - 1; i > active_tab_index; --i) {
+    for (int i = GetTabCount() - 1; i > active_tab_index; --i) {
       Tab* tab = tab_at(i);
       tab->Paint(canvas, cull_set);
     }
   }
   if (inactive_tab_alpha < 255)
     canvas->Restore();
 
   if (GetWidget()->ShouldWindowContentsBeTransparent()) {
     // Make sure non-active tabs are somewhat transparent.
     SkPaint paint;
@@ skipping 42 matching lines @@
   int needed_tab_width;
   if (touch_layout_ || adjust_layout_) {
     // For stacked tabs the minimum size is calculated as the size needed to
     // handle showing any number of tabs.
     needed_tab_width =
         Tab::GetTouchWidth() + (2 * kStackedPadding * kMaxStackedCount);
   } else {
     // Otherwise the minimum width is based on the actual number of tabs.
     const int mini_tab_count = GetMiniTabCount();
     needed_tab_width = mini_tab_count * Tab::GetMiniWidth();
-    const int remaining_tab_count = tab_count() - mini_tab_count;
+    const int remaining_tab_count = GetTabCount() - mini_tab_count;
     const int min_selected_width = Tab::GetMinimumSelectedSize().width();
     const int min_unselected_width = Tab::GetMinimumUnselectedSize().width();
     if (remaining_tab_count > 0) {
       needed_tab_width += kMiniToNonMiniGap + min_selected_width +
           ((remaining_tab_count - 1) * min_unselected_width);
     }
-    if (tab_count() > 1)
-      needed_tab_width += (tab_count() - 1) * kTabHorizontalOffset;
+    if (GetTabCount() > 1)
+      needed_tab_width += (GetTabCount() - 1) * kTabHorizontalOffset;
 
     // Don't let the tabstrip shrink smaller than is necessary to show one tab,
     // and don't force it to be larger than is necessary to show 20 tabs.
     const int largest_min_tab_width =
         min_selected_width + 19 * (min_unselected_width + kTabHorizontalOffset);
     needed_tab_width = std::min(
         std::max(needed_tab_width, min_selected_width), largest_min_tab_width);
   }
   return gfx::Size(
       needed_tab_width + new_tab_button_width(),
@@ skipping 117 matching lines @@
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetTooltipHandler(this, tab, point);
   }
   return this;
 }
 
+int TabStrip::GetModelIndexOfTab(const Tab* tab) const {
+  return tabs_.GetIndexOfView(tab);
+}
+
+int TabStrip::GetTabCount() const {
+  return tabs_.view_size();
+}
+
 // static
 int TabStrip::GetImmersiveHeight() {
   return Tab::GetImmersiveHeight();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
@@ skipping 86 matching lines @@
   // Don't animate the new tab button when dragging tabs. Otherwise it looks
   // like the new tab button magically appears from beyond the end of the tab
   // strip.
   if (TabDragController::IsAttachedTo(this)) {
     bounds_animator_.StopAnimatingView(newtab_button_);
     newtab_button_->SetBoundsRect(newtab_button_bounds_);
   }
 }
 
 void TabStrip::AnimateToIdealBounds() {
-  for (int i = 0; i < tab_count(); ++i) {
+  for (int i = 0; i < GetTabCount(); ++i) {
     Tab* tab = tab_at(i);
     if (!tab->dragging()) {
       bounds_animator_.AnimateViewTo(tab, ideal_bounds(i));
       bounds_animator_.SetAnimationDelegate(
           tab,
           scoped_ptr<gfx::AnimationDelegate>(
               new TabAnimationDelegate(this, tab)));
     }
   }
 
@@ skipping 24 matching lines @@
   bounds_animator_.StopAnimatingView(newtab_button_);
   newtab_button_->SetBoundsRect(newtab_button_bounds_);
 }
 
 void TabStrip::SetTabVisibility() {
   // We could probably be more efficient here by making use of the fact that the
   // tabstrip will always have any visible tabs, and then any invisible tabs, so
   // we could e.g. binary-search for the changeover point.  But since we have to
   // iterate through all the tabs to call SetVisible() anyway, it doesn't seem
   // worth it.
-  for (int i = 0; i < tab_count(); ++i) {
+  for (int i = 0; i < GetTabCount(); ++i) {
     Tab* tab = tab_at(i);
     tab->SetVisible(ShouldTabBeVisible(tab));
   }
   for (TabsClosingMap::const_iterator i(tabs_closing_map_.begin());
        i != tabs_closing_map_.end(); ++i) {
     for (Tabs::const_iterator j(i->second.begin()); j != i->second.end(); ++j) {
       Tab* tab = *j;
       tab->SetVisible(ShouldTabBeVisible(tab));
     }
   }
 }
 
 void TabStrip::DragActiveTab(const std::vector<int>& initial_positions,
                              int delta) {
-  DCHECK_EQ(tab_count(), static_cast<int>(initial_positions.size()));
+  DCHECK_EQ(GetTabCount(), static_cast<int>(initial_positions.size()));
   if (!touch_layout_) {
     StackDraggedTabs(delta);
     return;
   }
   SetIdealBoundsFromPositions(initial_positions);
   touch_layout_->DragActiveTab(delta);
   DoLayout();
 }
 
 void TabStrip::SetIdealBoundsFromPositions(const std::vector<int>& positions) {
-  if (static_cast<size_t>(tab_count()) != positions.size())
+  if (static_cast<size_t>(GetTabCount()) != positions.size())
     return;
 
-  for (int i = 0; i < tab_count(); ++i) {
+  for (int i = 0; i < GetTabCount(); ++i) {
     gfx::Rect bounds(ideal_bounds(i));
     bounds.set_x(positions[i]);
     tabs_.set_ideal_bounds(i, bounds);
   }
 }
 
 void TabStrip::StackDraggedTabs(int delta) {
   DCHECK(!touch_layout_);
   GenerateIdealBounds();
   const int active_index = controller_->GetActiveIndex();
   DCHECK_NE(-1, active_index);
   if (delta < 0) {
     // Drag the tabs to the left, stacking tabs before the active tab.
     const int adjusted_delta =
         std::min(ideal_bounds(active_index).x() -
                      kStackedPadding * std::min(active_index, kMaxStackedCount),
                  -delta);
     for (int i = 0; i <= active_index; ++i) {
       const int min_x = std::min(i, kMaxStackedCount) * kStackedPadding;
       gfx::Rect new_bounds(ideal_bounds(i));
       new_bounds.set_x(std::max(min_x, new_bounds.x() - adjusted_delta));
       tabs_.set_ideal_bounds(i, new_bounds);
     }
     const bool is_active_mini = tab_at(active_index)->data().mini;
     const int active_width = ideal_bounds(active_index).width();
-    for (int i = active_index + 1; i < tab_count(); ++i) {
+    for (int i = active_index + 1; i < GetTabCount(); ++i) {
       const int max_x = ideal_bounds(active_index).x() +
           (kStackedPadding * std::min(i - active_index, kMaxStackedCount));
       gfx::Rect new_bounds(ideal_bounds(i));
       int new_x = std::max(new_bounds.x() + delta, max_x);
       if (new_x == max_x && !tab_at(i)->data().mini && !is_active_mini &&
           new_bounds.width() != active_width)
         new_x += (active_width - new_bounds.width());
       new_bounds.set_x(new_x);
       tabs_.set_ideal_bounds(i, new_bounds);
     }
   } else {
     // Drag the tabs to the right, stacking tabs after the active tab.
-    const int last_tab_width = ideal_bounds(tab_count() - 1).width();
+    const int last_tab_width = ideal_bounds(GetTabCount() - 1).width();
     const int last_tab_x = tab_area_width() - last_tab_width;
-    if (active_index == tab_count() - 1 &&
-        ideal_bounds(tab_count() - 1).x() == last_tab_x)
+    if (active_index == GetTabCount() - 1 &&
+        ideal_bounds(GetTabCount() - 1).x() == last_tab_x)
       return;
-    const int adjusted_delta =
-        std::min(last_tab_x -
-                     kStackedPadding * std::min(tab_count() - active_index - 1,
-                                                kMaxStackedCount) -
-                     ideal_bounds(active_index).x(),
-                 delta);
-    for (int last_index = tab_count() - 1, i = last_index; i >= active_index;
+    const int adjusted_delta = std::min(
+        last_tab_x -
+            kStackedPadding *
+                std::min(GetTabCount() - active_index - 1, kMaxStackedCount) -
+            ideal_bounds(active_index).x(),
+        delta);
+    for (int last_index = GetTabCount() - 1, i = last_index; i >= active_index;
          --i) {
       const int max_x = last_tab_x -
-          std::min(tab_count() - i - 1, kMaxStackedCount) * kStackedPadding;
+          std::min(GetTabCount() - i - 1, kMaxStackedCount) * kStackedPadding;
       gfx::Rect new_bounds(ideal_bounds(i));
       int new_x = std::min(max_x, new_bounds.x() + adjusted_delta);
       // Because of rounding not all tabs are the same width. Adjust the
       // position to accommodate this, otherwise the stacking is off.
       if (new_x == max_x && !tab_at(i)->data().mini &&
           new_bounds.width() != last_tab_width)
         new_x += (last_tab_width - new_bounds.width());
       new_bounds.set_x(new_x);
       tabs_.set_ideal_bounds(i, new_bounds);
     }
     for (int i = active_index - 1; i >= 0; --i) {
       const int min_x = ideal_bounds(active_index).x() -
           std::min(active_index - i, kMaxStackedCount) * kStackedPadding;
       gfx::Rect new_bounds(ideal_bounds(i));
       new_bounds.set_x(std::min(min_x, new_bounds.x() + delta));
       tabs_.set_ideal_bounds(i, new_bounds);
     }
-    if (ideal_bounds(tab_count() - 1).right() >= newtab_button_->x())
+    if (ideal_bounds(GetTabCount() - 1).right() >= newtab_button_->x())
       newtab_button_->SetVisible(false);
   }
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
   SchedulePaint();
 }
 
 bool TabStrip::IsStackingDraggedTabs() const {
   return drag_controller_.get() && drag_controller_->started_drag() &&
       (drag_controller_->move_behavior() ==
        TabDragController::MOVE_VISIBILE_TABS);
@@ skipping 55 matching lines @@
     if (i > 0 && tab->data().mini != tabs[i - 1]->data().mini)
       width += kMiniToNonMiniGap;
   }
   if (tabs.size() > 0)
     width += kTabHorizontalOffset * static_cast<int>(tabs.size() - 1);
   return width;
 }
 
 int TabStrip::GetMiniTabCount() const {
   int mini_count = 0;
-  while (mini_count < tab_count() && tab_at(mini_count)->data().mini)
+  while (mini_count < GetTabCount() && tab_at(mini_count)->data().mini)
     mini_count++;
   return mini_count;
 }
 
 const Tab* TabStrip::GetLastVisibleTab() const {
-  for (int i = tab_count() - 1; i >= 0; --i) {
+  for (int i = GetTabCount() - 1; i >= 0; --i) {
     const Tab* tab = tab_at(i);
     if (tab->visible())
       return tab;
   }
   // While in normal use the tabstrip should always be wide enough to have at
   // least one visible tab, it can be zero-width in tests, meaning we get here.
   return NULL;
 }
 
 void TabStrip::RemoveTabFromViewModel(int index) {
@@ skipping 40 matching lines @@
   // Let the controller know that the user started dragging tabs.
   controller()->OnStartedDraggingTabs();
 
   // Hide the new tab button immediately if we didn't originate the drag.
   if (!drag_controller_.get())
     newtab_button_->SetVisible(false);
 
   PrepareForAnimation();
 
   // Reset dragging state of existing tabs.
-  for (int i = 0; i < tab_count(); ++i)
+  for (int i = 0; i < GetTabCount(); ++i)
     tab_at(i)->set_dragging(false);
 
   for (size_t i = 0; i < tabs.size(); ++i) {
     tabs[i]->set_dragging(true);
     bounds_animator_.StopAnimatingView(tabs[i]);
   }
 
   // Move the dragged tabs to their ideal bounds.
   GenerateIdealBounds();
 
@@ skipping 242 matching lines @@
           available_width - total_offset - min_selected_width) /
           static_cast<double>(tab_count - 1), min_unselected_width);
     }
   }
 }
 
 void TabStrip::ResizeLayoutTabs() {
   // We've been called back after the TabStrip has been emptied out (probably
   // just prior to the window being destroyed). We need to do nothing here or
   // else GetTabAt below will crash.
-  if (tab_count() == 0)
+  if (GetTabCount() == 0)
     return;
 
   // It is critically important that this is unhooked here, otherwise we will
   // keep spying on messages forever.
   RemoveMessageLoopObserver();
 
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
   int mini_tab_count = GetMiniTabCount();
-  if (mini_tab_count == tab_count()) {
+  if (mini_tab_count == GetTabCount()) {
     // Only mini-tabs, we know the tab widths won't have changed (all
     // mini-tabs have the same width), so there is nothing to do.
     return;
   }
   // Don't try and avoid layout based on tab sizes. If tabs are small enough
   // then the width of the active tab may not change, but other widths may
   // have. This is particularly important if we've overflowed (all tabs are at
   // the min).
   StartResizeLayoutAnimation();
 }
 
 void TabStrip::ResizeLayoutTabsFromTouch() {
   // Don't resize if the user is interacting with the tabstrip.
   if (!drag_controller_.get())
     ResizeLayoutTabs();
   else
     StartResizeLayoutTabsFromTouchTimer();
 }
 
 void TabStrip::StartResizeLayoutTabsFromTouchTimer() {
   resize_layout_timer_.Stop();
   resize_layout_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(kTouchResizeLayoutTimeMS),
       this, &TabStrip::ResizeLayoutTabsFromTouch);
 }
 
 void TabStrip::SetTabBoundsForDrag(const std::vector<gfx::Rect>& tab_bounds) {
   StopAnimating(false);
-  DCHECK_EQ(tab_count(), static_cast<int>(tab_bounds.size()));
-  for (int i = 0; i < tab_count(); ++i)
+  DCHECK_EQ(GetTabCount(), static_cast<int>(tab_bounds.size()));
+  for (int i = 0; i < GetTabCount(); ++i)
     tab_at(i)->SetBoundsRect(tab_bounds[i]);
   // Reset the layout size as we've effectively layed out a different size.
   // This ensures a layout happens after the drag is done.
   last_layout_size_ = gfx::Size();
 }
 
 void TabStrip::AddMessageLoopObserver() {
   if (!mouse_watcher_.get()) {
     mouse_watcher_.reset(
         new views::MouseWatcher(
             new views::MouseWatcherViewHost(
                 this, gfx::Insets(0, 0, kTabStripAnimationVSlop, 0)),
             this));
   }
   mouse_watcher_->Start();
 }
 
 void TabStrip::RemoveMessageLoopObserver() {
   mouse_watcher_.reset(NULL);
 }
 
 gfx::Rect TabStrip::GetDropBounds(int drop_index,
                                   bool drop_before,
                                   bool* is_beneath) {
   DCHECK_NE(drop_index, -1);
   int center_x;
-  if (drop_index < tab_count()) {
+  if (drop_index < GetTabCount()) {
     Tab* tab = tab_at(drop_index);
     if (drop_before)
       center_x = tab->x() - (kTabHorizontalOffset / 2);
     else
       center_x = tab->x() + (tab->width() / 2);
   } else {
     Tab* last_tab = tab_at(drop_index - 1);
     center_x = last_tab->x() + last_tab->width() + (kTabHorizontalOffset / 2);
   }
 
@@ skipping 16 matching lines @@
 
   return drop_bounds;
 }
 
 void TabStrip::UpdateDropIndex(const DropTargetEvent& event) {
   // If the UI layout is right-to-left, we need to mirror the mouse
   // coordinates since we calculate the drop index based on the
   // original (and therefore non-mirrored) positions of the tabs.
   const int x = GetMirroredXInView(event.x());
   // We don't allow replacing the urls of mini-tabs.
-  for (int i = GetMiniTabCount(); i < tab_count(); ++i) {
+  for (int i = GetMiniTabCount(); i < GetTabCount(); ++i) {
     Tab* tab = tab_at(i);
     const int tab_max_x = tab->x() + tab->width();
     const int hot_width = tab->width() / kTabEdgeRatioInverse;
     if (x < tab_max_x) {
       if (x < tab->x() + hot_width)
         SetDropIndex(i, true);
       else if (x >= tab_max_x - hot_width)
         SetDropIndex(i + 1, true);
       else
         SetDropIndex(i, false);
       return;
     }
   }
 
   // The drop isn't over a tab, add it to the end.
-  SetDropIndex(tab_count(), true);
+  SetDropIndex(GetTabCount(), true);
 }
 
 void TabStrip::SetDropIndex(int tab_data_index, bool drop_before) {
   // Let the controller know of the index update.
   controller()->OnDropIndexUpdate(tab_data_index, drop_before);
 
   if (tab_data_index == -1) {
     if (drop_info_.get())
       drop_info_.reset(NULL);
     return;
@@ skipping 68 matching lines @@
 
 TabStrip::DropInfo::~DropInfo() {
   // Close eventually deletes the window, which deletes arrow_view too.
   arrow_window->Close();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void TabStrip::PrepareForAnimation() {
   if (!IsDragSessionActive() && !TabDragController::IsAttachedTo(this)) {
-    for (int i = 0; i < tab_count(); ++i)
+    for (int i = 0; i < GetTabCount(); ++i)
       tab_at(i)->set_dragging(false);
   }
 }
 
 void TabStrip::GenerateIdealBounds() {
   int new_tab_y = 0;
 
   if (touch_layout_) {
     if (tabs_.view_size() == 0)
       return;
 
     int new_tab_x = tabs_.ideal_bounds(tabs_.view_size() - 1).right() +
         kNewTabButtonHorizontalOffset;
     newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
     return;
   }
 
-  GetDesiredTabWidths(tab_count(), GetMiniTabCount(),
+  GetDesiredTabWidths(GetTabCount(), GetMiniTabCount(),
                       &current_unselected_width_, &current_selected_width_);
 
   // NOTE: This currently assumes a tab's height doesn't differ based on
   // selected state or the number of tabs in the strip!
   int tab_height = Tab::GetStandardSize().height();
   int first_non_mini_index = 0;
   double tab_x = GenerateIdealBoundsForMiniTabs(&first_non_mini_index);
-  for (int i = first_non_mini_index; i < tab_count(); ++i) {
+  for (int i = first_non_mini_index; i < GetTabCount(); ++i) {
     Tab* tab = tab_at(i);
     DCHECK(!tab->data().mini);
     double tab_width =
         tab->IsActive() ? current_selected_width_ : current_unselected_width_;
     double end_of_tab = tab_x + tab_width;
     int rounded_tab_x = Round(tab_x);
     tabs_.set_ideal_bounds(
         i,
         gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                   tab_height));
@@ skipping 13 matching lines @@
         kNewTabButtonHorizontalOffset;
   }
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
 }
 
 int TabStrip::GenerateIdealBoundsForMiniTabs(int* first_non_mini_index) {
   int next_x = 0;
   int mini_width = Tab::GetMiniWidth();
   int tab_height = Tab::GetStandardSize().height();
   int index = 0;
-  for (; index < tab_count() && tab_at(index)->data().mini; ++index) {
+  for (; index < GetTabCount() && tab_at(index)->data().mini; ++index) {
     tabs_.set_ideal_bounds(index, gfx::Rect(next_x, 0, mini_width, tab_height));
     next_x += mini_width + kTabHorizontalOffset;
   }
-  if (index > 0 && index < tab_count())
+  if (index > 0 && index < GetTabCount())
     next_x += kMiniToNonMiniGap;
   if (first_non_mini_index)
     *first_non_mini_index = index;
   return next_x;
 }
 
 void TabStrip::StartResizeLayoutAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMiniTabAnimation() {
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
 
   PrepareForAnimation();
 
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMouseInitiatedRemoveTabAnimation(int model_index) {
   // The user initiated the close. We want to persist the bounds of all the
   // existing tabs, so we manually shift ideal_bounds then animate.
   Tab* tab_closing = tab_at(model_index);
   int delta = tab_closing->width() + kTabHorizontalOffset;
   // If the tab being closed is a mini-tab next to a non-mini-tab, be sure to
   // add the extra padding.
-  DCHECK_LT(model_index, tab_count() - 1);
+  DCHECK_LT(model_index, GetTabCount() - 1);
   if (tab_closing->data().mini && !tab_at(model_index + 1)->data().mini)
     delta += kMiniToNonMiniGap;
 
-  for (int i = model_index + 1; i < tab_count(); ++i) {
+  for (int i = model_index + 1; i < GetTabCount(); ++i) {
     gfx::Rect bounds = ideal_bounds(i);
     bounds.set_x(bounds.x() - delta);
     tabs_.set_ideal_bounds(i, bounds);
   }
 
   // Don't just subtract |delta| from the New Tab x-coordinate, as we might have
   // overflow tabs that will be able to animate into the strip, in which case
   // the new tab button should stay where it is.
   newtab_button_bounds_.set_x(std::min(
       width() - newtab_button_bounds_.width(),
-      ideal_bounds(tab_count() - 1).right() + kNewTabButtonHorizontalOffset));
+      ideal_bounds(GetTabCount() - 1).right() + kNewTabButtonHorizontalOffset));
 
   PrepareForAnimation();
 
   tab_closing->set_closing(true);
 
   // We still need to paint the tab until we actually remove it. Put it in
   // tabs_closing_map_ so we can find it.
   RemoveTabFromViewModel(model_index);
 
   AnimateToIdealBounds();
@@ skipping 27 matching lines @@
 
 Tab* TabStrip::FindTabForEvent(const gfx::Point& point) {
   if (touch_layout_) {
     int active_tab_index = touch_layout_->active_index();
     if (active_tab_index != -1) {
       Tab* tab = FindTabForEventFrom(point, active_tab_index, -1);
       if (!tab)
         tab = FindTabForEventFrom(point, active_tab_index + 1, 1);
       return tab;
     }
-    if (tab_count())
+    if (GetTabCount())
       return FindTabForEventFrom(point, 0, 1);
   } else {
-    for (int i = 0; i < tab_count(); ++i) {
+    for (int i = 0; i < GetTabCount(); ++i) {
       if (IsPointInTab(tab_at(i), point))
         return tab_at(i);
     }
   }
   return NULL;
 }
 
 Tab* TabStrip::FindTabForEventFrom(const gfx::Point& point,
                                    int start,
                                    int delta) {
-  // |start| equals tab_count() when there are only pinned tabs.
-  if (start == tab_count())
+  // |start| equals GetTabCount() when there are only pinned tabs.
+  if (start == GetTabCount())
     start += delta;
-  for (int i = start; i >= 0 && i < tab_count(); i += delta) {
+  for (int i = start; i >= 0 && i < GetTabCount(); i += delta) {
     if (IsPointInTab(tab_at(i), point))
       return tab_at(i);
   }
   return NULL;
 }
 
 views::View* TabStrip::FindTabHitByPoint(const gfx::Point& point) {
   // The display order doesn't necessarily match the child list order, so we
   // walk the display list hit-testing Tabs. Since the active tab always
   // renders on top of adjacent tabs, it needs to be hit-tested before any
   // left-adjacent Tab, so we look ahead for it as we walk.
-  for (int i = 0; i < tab_count(); ++i) {
-    Tab* next_tab = i < (tab_count() - 1) ? tab_at(i + 1) : NULL;
+  for (int i = 0; i < GetTabCount(); ++i) {
+    Tab* next_tab = i < (GetTabCount() - 1) ? tab_at(i + 1) : NULL;
     if (next_tab && next_tab->IsActive() && IsPointInTab(next_tab, point))
       return next_tab;
     if (IsPointInTab(tab_at(i), point))
       return tab_at(i);
   }
 
   return NULL;
 }
 
 std::vector<int> TabStrip::GetTabXCoordinates() {
   std::vector<int> results;
-  for (int i = 0; i < tab_count(); ++i)
+  for (int i = 0; i < GetTabCount(); ++i)
     results.push_back(ideal_bounds(i).x());
   return results;
 }
 
 void TabStrip::SwapLayoutIfNecessary() {
   bool needs_touch = NeedsTouchLayout();
   bool using_touch = touch_layout_ != NULL;
   if (needs_touch == using_touch)
     return;
 
@@ skipping 21 matching lines @@
   GenerateIdealBounds();
   SetTabVisibility();
   AnimateToIdealBounds();
 }
 
 bool TabStrip::NeedsTouchLayout() const {
   if (!stacked_layout_)
     return false;
 
   int mini_tab_count = GetMiniTabCount();
-  int normal_count = tab_count() - mini_tab_count;
+  int normal_count = GetTabCount() - mini_tab_count;
   if (normal_count <= 1 || normal_count == mini_tab_count)
     return false;
   int x = GetStartXForNormalTabs();
   int available_width = tab_area_width() - x;
   return (Tab::GetTouchWidth() * normal_count +
           kTabHorizontalOffset * (normal_count - 1)) > available_width;
 }
 
 void TabStrip::SetResetToShrinkOnExit(bool value) {
   if (!adjust_layout_)
@@ skipping 29 matching lines @@
     }
 
     controller()->CreateNewTab();
     if (event.type() == ui::ET_GESTURE_TAP)
       TouchUMA::RecordGestureAction(TouchUMA::GESTURE_NEWTAB_TAP);
   }
 }
 
 // Overridden to support automation. See automation_proxy_uitest.cc.
 const views::View* TabStrip::GetViewByID(int view_id) const {
-  if (tab_count() > 0) {
+  if (GetTabCount() > 0) {
     if (view_id == VIEW_ID_TAB_LAST)
-      return tab_at(tab_count() - 1);
+      return tab_at(GetTabCount() - 1);
     if ((view_id >= VIEW_ID_TAB_0) && (view_id < VIEW_ID_TAB_LAST)) {
       int index = view_id - VIEW_ID_TAB_0;
-      return (index >= 0 && index < tab_count()) ? tab_at(index) : NULL;
+      return (index >= 0 && index < GetTabCount()) ? tab_at(index) : NULL;
     }
   }
 
   return View::GetViewByID(view_id);
 }
 
 bool TabStrip::OnMousePressed(const ui::MouseEvent& event) {
   UpdateStackedLayoutFromMouseEvent(this, event);
   // We can't return true here, else clicking in an empty area won't drag the
   // window.
@@ skipping 68 matching lines @@
         action = TouchUMA::GESTURE_TABSWITCH_TAP;
       TouchUMA::RecordGestureAction(action);
       break;
     }
 
     default:
       break;
   }
   event->SetHandled();
 }