Added tab notification to accessibility_event_router_views.

chrome/browser/ui/views/tabs/tab_strip_unittest.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"
 
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/ui/views/tabs/fake_base_tab_strip_controller.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
@@ skipping 160 matching lines @@
 
 TEST_F(TabStripTest, GetModelCount) {
   EXPECT_EQ(0, tab_strip_->GetModelCount());
 }
 
 TEST_F(TabStripTest, IsValidModelIndex) {
   EXPECT_FALSE(tab_strip_->IsValidModelIndex(0));
 }
 
 TEST_F(TabStripTest, tab_count) {
-  EXPECT_EQ(0, tab_strip_->tab_count());
+  EXPECT_EQ(0, tab_strip_->GetTabCount());
 }
 
 TEST_F(TabStripTest, AddTabAt) {
   TestTabStripObserver observer(tab_strip_);
   tab_strip_->AddTabAt(0, TabRendererData(), false);
-  ASSERT_EQ(1, tab_strip_->tab_count());
+  ASSERT_EQ(1, tab_strip_->GetTabCount());
   EXPECT_EQ(0, observer.last_tab_added());
   Tab* tab = tab_strip_->tab_at(0);
   EXPECT_FALSE(tab == NULL);
 }
 
 // Confirms that TabStripObserver::TabStripDeleted() is sent.
 TEST_F(TabStripTest, TabStripDeleted) {
   FakeBaseTabStripController* controller = new FakeBaseTabStripController;
   TabStrip* tab_strip = new TabStrip(controller);
   controller->set_tab_strip(tab_strip);
   TestTabStripObserver observer(tab_strip);
   delete tab_strip;
   EXPECT_TRUE(observer.tabstrip_deleted());
 }
 
 TEST_F(TabStripTest, MoveTab) {
   TestTabStripObserver observer(tab_strip_);
   tab_strip_->AddTabAt(0, TabRendererData(), false);
   tab_strip_->AddTabAt(1, TabRendererData(), false);
   tab_strip_->AddTabAt(2, TabRendererData(), false);
-  ASSERT_EQ(3, tab_strip_->tab_count());
+  ASSERT_EQ(3, tab_strip_->GetTabCount());
   EXPECT_EQ(2, observer.last_tab_added());
   Tab* tab = tab_strip_->tab_at(0);
   tab_strip_->MoveTab(0, 1, TabRendererData());
   EXPECT_EQ(0, observer.last_tab_moved_from());
   EXPECT_EQ(1, observer.last_tab_moved_to());
   EXPECT_EQ(tab, tab_strip_->tab_at(1));
 }
 
 // Verifies child views are deleted after an animation completes.
 TEST_F(TabStripTest, RemoveTab) {
   TestTabStripObserver observer(tab_strip_);
   controller_->AddTab(0, false);
   controller_->AddTab(1, false);
   const int child_view_count = tab_strip_->child_count();
-  EXPECT_EQ(2, tab_strip_->tab_count());
+  EXPECT_EQ(2, tab_strip_->GetTabCount());
   controller_->RemoveTab(0);
   EXPECT_EQ(0, observer.last_tab_removed());
   // When removing a tab the tabcount should immediately decrement.
-  EXPECT_EQ(1, tab_strip_->tab_count());
+  EXPECT_EQ(1, tab_strip_->GetTabCount());
   // But the number of views should remain the same (it's animatining closed).
   EXPECT_EQ(child_view_count, tab_strip_->child_count());
   tab_strip_->SetBounds(0, 0, 200, 20);
   // Layout at a different size should force the animation to end and delete
   // the tab that was removed.
   tab_strip_->Layout();
   EXPECT_EQ(child_view_count - 1, tab_strip_->child_count());
 
   // Remove the last tab to make sure things are cleaned up correctly when
   // the TabStrip is destroyed and an animation is ongoing.
@@ skipping 32 matching lines @@
   // All the invisible tabs should be at the end of the strip.
   tab_strip_->SetBounds(0, 0, 100, 20);
   int i = 0;
   for (; i < invisible_tab_index; ++i) {
     if (!tab_strip_->tab_at(i)->visible())
       break;
   }
   ASSERT_GT(i, 0);
   EXPECT_LT(i, invisible_tab_index);
   invisible_tab_index = i;
-  for (int i = invisible_tab_index + 1; i < tab_strip_->tab_count(); ++i)
+  for (int i = invisible_tab_index + 1; i < tab_strip_->GetTabCount(); ++i)
     EXPECT_FALSE(tab_strip_->tab_at(i)->visible());
 
   // When we're already in overflow, adding tabs at the beginning or end of
   // the strip should not change how many tabs are visible.
-  controller_->AddTab(tab_strip_->tab_count(), false);
+  controller_->AddTab(tab_strip_->GetTabCount(), false);
   EXPECT_TRUE(tab_strip_->tab_at(invisible_tab_index - 1)->visible());
   EXPECT_FALSE(tab_strip_->tab_at(invisible_tab_index)->visible());
   controller_->AddTab(0, false);
   EXPECT_TRUE(tab_strip_->tab_at(invisible_tab_index - 1)->visible());
   EXPECT_FALSE(tab_strip_->tab_at(invisible_tab_index)->visible());
 
   // If we remove enough tabs, all the tabs should be visible.
-  for (int i = tab_strip_->tab_count() - 1; i >= invisible_tab_index; --i)
+  for (int i = tab_strip_->GetTabCount() - 1; i >= invisible_tab_index; --i)
     controller_->RemoveTab(i);
-  EXPECT_TRUE(tab_strip_->tab_at(tab_strip_->tab_count() - 1)->visible());
+  EXPECT_TRUE(tab_strip_->tab_at(tab_strip_->GetTabCount() - 1)->visible());
 }
 
 TEST_F(TabStripTest, ImmersiveMode) {
   // Immersive mode defaults to off.
   EXPECT_FALSE(tab_strip_->IsImmersiveStyle());
 
   // Tab strip defaults to normal tab height.
   int normal_height = Tab::GetMinimumUnselectedSize().height();
   EXPECT_EQ(normal_height, tab_strip_->GetPreferredSize().height());
 
@@ skipping 12 matching lines @@
 // Creates a tab strip in stacked layout mode and verifies the correctness
 // of hit tests against the visible/occluded regions of a tab and
 // visible/occluded tab close buttons.
 TEST_F(TabStripTest, TabHitTestMaskWhenStacked) {
   tab_strip_->SetBounds(0, 0, 300, 20);
 
   controller_->AddTab(0, false);
   controller_->AddTab(1, true);
   controller_->AddTab(2, false);
   controller_->AddTab(3, false);
-  ASSERT_EQ(4, tab_strip_->tab_count());
+  ASSERT_EQ(4, tab_strip_->GetTabCount());
 
   Tab* left_tab = tab_strip_->tab_at(0);
   left_tab->SetBoundsRect(gfx::Rect(gfx::Point(0, 0), gfx::Size(200, 20)));
 
   Tab* active_tab = tab_strip_->tab_at(1);
   active_tab->SetBoundsRect(gfx::Rect(gfx::Point(150, 0), gfx::Size(200, 20)));
   ASSERT_TRUE(active_tab->IsActive());
 
   Tab* right_tab = tab_strip_->tab_at(2);
   right_tab->SetBoundsRect(gfx::Rect(gfx::Point(300, 0), gfx::Size(200, 20)));
@@ skipping 112 matching lines @@
 }
 
 // Creates a tab strip in stacked layout mode and verifies the correctness
 // of hit tests against the visible/occluded region of a partially-occluded
 // tab close button.
 TEST_F(TabStripTest, ClippedTabCloseButton) {
   tab_strip_->SetBounds(0, 0, 220, 20);
 
   controller_->AddTab(0, false);
   controller_->AddTab(1, true);
-  ASSERT_EQ(2, tab_strip_->tab_count());
+  ASSERT_EQ(2, tab_strip_->GetTabCount());
 
   Tab* left_tab = tab_strip_->tab_at(0);
   left_tab->SetBoundsRect(gfx::Rect(gfx::Point(0, 0), gfx::Size(200, 20)));
 
   Tab* active_tab = tab_strip_->tab_at(1);
   active_tab->SetBoundsRect(gfx::Rect(gfx::Point(180, 0), gfx::Size(200, 20)));
   ASSERT_TRUE(active_tab->IsActive());
 
   // Switch to stacked layout mode and force a layout to ensure tabs stack.
   tab_strip_->SetStackedLayout(true);
@@ skipping 36 matching lines @@
   EXPECT_FALSE(left_close->HitTestRect(gfx::Rect(16, 10, 20, 20)));
 }
 
 TEST_F(TabStripTest, GetEventHandlerForOverlappingArea) {
   tab_strip_->SetBounds(0, 0, 1000, 20);
 
   controller_->AddTab(0, false);
   controller_->AddTab(1, true);
   controller_->AddTab(2, false);
   controller_->AddTab(3, false);
-  ASSERT_EQ(4, tab_strip_->tab_count());
+  ASSERT_EQ(4, tab_strip_->GetTabCount());
 
   // Verify that the active tab will be a tooltip handler for points that hit
   // it.
   Tab* left_tab = tab_strip_->tab_at(0);
   left_tab->SetBoundsRect(gfx::Rect(gfx::Point(0, 0), gfx::Size(200, 20)));
 
   Tab* active_tab = tab_strip_->tab_at(1);
   active_tab->SetBoundsRect(gfx::Rect(gfx::Point(150, 0), gfx::Size(200, 20)));
   ASSERT_TRUE(active_tab->IsActive());
 
@@ skipping 42 matching lines @@
             FindTabView(tab_strip_->GetEventHandlerForPoint(unactive_overlap)));
 }
 
 TEST_F(TabStripTest, GetTooltipHandler) {
   tab_strip_->SetBounds(0, 0, 1000, 20);
 
   controller_->AddTab(0, false);
   controller_->AddTab(1, true);
   controller_->AddTab(2, false);
   controller_->AddTab(3, false);
-  ASSERT_EQ(4, tab_strip_->tab_count());
+  ASSERT_EQ(4, tab_strip_->GetTabCount());
 
   // Verify that the active tab will be a tooltip handler for points that hit
   // it.
   Tab* left_tab = tab_strip_->tab_at(0);
   left_tab->SetBoundsRect(gfx::Rect(gfx::Point(0, 0), gfx::Size(200, 20)));
 
   Tab* active_tab = tab_strip_->tab_at(1);
   active_tab->SetBoundsRect(gfx::Rect(gfx::Point(150, 0), gfx::Size(200, 20)));
   ASSERT_TRUE(active_tab->IsActive());
 
@@ skipping 39 matching lines @@
   ASSERT_TRUE(IsPointInTab(most_right_tab, unactive_overlap));
 
   EXPECT_EQ(
       right_tab,
       FindTabView(tab_strip_->GetTooltipHandlerForPoint(unactive_overlap)));
 
   // Confirm that tab strip doe not return tooltip handler for points that
   // don't hit it.
   EXPECT_FALSE(tab_strip_->GetTooltipHandlerForPoint(gfx::Point(-1, 2)));
 }