Added tab notification to accessibility_event_router_views.

chrome/browser/ui/views/tabs/tab_drag_controller.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_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "ash/accelerators/accelerator_commands.h"
@@ skipping 598 matching lines @@
     end_run_loop_behavior_ = END_RUN_LOOP_CONTINUE_DRAGGING;
     return DRAG_BROWSER_RESULT_STOP;
   }
   Detach(DONT_RELEASE_CAPTURE);
   Attach(target_tabstrip, point_in_screen);
   return DRAG_BROWSER_RESULT_CONTINUE;
 }
 
 void TabDragController::DragActiveTabStacked(
     const gfx::Point& point_in_screen) {
-  if (attached_tabstrip_->tab_count() !=
+  if (attached_tabstrip_->GetTabCount() !=
       static_cast<int>(initial_tab_positions_.size()))
     return;  // TODO: should cancel drag if this happens.
 
   int delta = point_in_screen.x() - start_point_in_screen_.x();
   attached_tabstrip_->DragActiveTab(initial_tab_positions_, delta);
 }
 
 void TabDragController::MoveAttachedToNextStackedIndex(
     const gfx::Point& point_in_screen) {
   int index = attached_tabstrip_->touch_layout_->active_index();
-  if (index + 1 >= attached_tabstrip_->tab_count())
+  if (index + 1 >= attached_tabstrip_->GetTabCount())
     return;
 
   GetModel(attached_tabstrip_)->MoveSelectedTabsTo(index + 1);
   StartMoveStackedTimerIfNecessary(point_in_screen,
                                    kMoveAttachedSubsequentDelay);
 }
 
 void TabDragController::MoveAttachedToPreviousStackedIndex(
     const gfx::Point& point_in_screen) {
   int index = attached_tabstrip_->touch_layout_->active_index();
@@ skipping 451 matching lines @@
     DCHECK(attached_tabstrip_);
     attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
   } else if (active_) {
     EndDrag(result == views::Widget::MOVE_LOOP_CANCELED ?
             END_DRAG_CANCEL : END_DRAG_COMPLETE);
   }
 }
 
 int TabDragController::GetInsertionIndexFrom(const gfx::Rect& dragged_bounds,
                                              int start) const {
-  const int last_tab = attached_tabstrip_->tab_count() - 1;
+  const int last_tab = attached_tabstrip_->GetTabCount() - 1;
   // Make the actual "drag insertion point" be just after the leading edge of
   // the first dragged tab.  This is closer to where the user thinks of the tab
   // as "starting" than just dragged_bounds.x(), especially with narrow tabs.
   const int dragged_x = dragged_bounds.x() + Tab::leading_width_for_drag();
   if (start < 0 || start > last_tab ||
       dragged_x < attached_tabstrip_->ideal_bounds(start).x())
     return -1;
 
   for (int i = start; i <= last_tab; ++i) {
     const gfx::Rect& ideal_bounds = attached_tabstrip_->ideal_bounds(i);
     if (dragged_x < (ideal_bounds.x() + (ideal_bounds.width() / 2)))
       return i;
   }
 
   return (dragged_x < attached_tabstrip_->ideal_bounds(last_tab).right()) ?
       (last_tab + 1) : -1;
 }
 
 int TabDragController::GetInsertionIndexFromReversed(
     const gfx::Rect& dragged_bounds,
     int start) const {
   // Make the actual "drag insertion point" be just after the leading edge of
   // the first dragged tab.  This is closer to where the user thinks of the tab
   // as "starting" than just dragged_bounds.x(), especially with narrow tabs.
   const int dragged_x = dragged_bounds.x() + Tab::leading_width_for_drag();
-  if (start < 0 || start >= attached_tabstrip_->tab_count() ||
+  if (start < 0 || start >= attached_tabstrip_->GetTabCount() ||
       dragged_x >= attached_tabstrip_->ideal_bounds(start).right())
     return -1;
 
   for (int i = start; i >= 0; --i) {
     const gfx::Rect& ideal_bounds = attached_tabstrip_->ideal_bounds(i);
     if (dragged_x >= (ideal_bounds.x() + (ideal_bounds.width() / 2)))
       return i + 1;
   }
 
   return (dragged_x >= attached_tabstrip_->ideal_bounds(0).x()) ? 0 : -1;
 }
 
 int TabDragController::GetInsertionIndexForDraggedBounds(
     const gfx::Rect& dragged_bounds) const {
   // If the strip has no tabs, the only position to insert at is 0.
-  const int tab_count = attached_tabstrip_->tab_count();
+  const int tab_count = attached_tabstrip_->GetTabCount();
   if (!tab_count)
     return 0;
 
   int index = -1;
   if (attached_tabstrip_->touch_layout_.get()) {
     index = GetInsertionIndexForDraggedBoundsStacked(dragged_bounds);
     if (index != -1) {
       // Only move the tab to the left/right if the user actually moved the
       // mouse that way. This is necessary as tabs with stacked tabs
       // before/after them have multiple drag positions.
@@ skipping 24 matching lines @@
         0, last_insertion_point - static_cast<int>(drag_data_.size()));
   }
 
   // Ensure the first dragged tab always stays in the visible index range.
   return std::min(index, last_insertion_point);
 }
 
 bool TabDragController::ShouldDragToNextStackedTab(
     const gfx::Rect& dragged_bounds,
     int index) const {
-  if (index + 1 >= attached_tabstrip_->tab_count() ||
+  if (index + 1 >= attached_tabstrip_->GetTabCount() ||
       !attached_tabstrip_->touch_layout_->IsStacked(index + 1) ||
       (mouse_move_direction_ & kMovedMouseRight) == 0)
     return false;
 
   int active_x = attached_tabstrip_->ideal_bounds(index).x();
   int next_x = attached_tabstrip_->ideal_bounds(index + 1).x();
   int mid_x = std::min(next_x - kStackedDistance,
                        active_x + (next_x - active_x) / 4);
   // TODO(pkasting): Should this add Tab::leading_width_for_drag() as
   // GetInsertionIndexFrom() does?
@@ skipping 26 matching lines @@
   int index = GetInsertionIndexFromReversed(dragged_bounds, active_index);
   if (index != active_index)
     return index;
   if (index == -1)
     return GetInsertionIndexFrom(dragged_bounds, active_index + 1);
 
   // The position to drag to corresponds to the active tab. If the next/previous
   // tab is stacked, then shorten the distance used to determine insertion
   // bounds. We do this as GetInsertionIndexFrom() uses the bounds of the
   // tabs. When tabs are stacked the next/previous tab is on top of the tab.
-  if (active_index + 1 < attached_tabstrip_->tab_count() &&
+  if (active_index + 1 < attached_tabstrip_->GetTabCount() &&
       touch_layout->IsStacked(active_index + 1)) {
     index = GetInsertionIndexFrom(dragged_bounds, active_index + 1);
     if (index == -1 && ShouldDragToNextStackedTab(dragged_bounds, active_index))
       index = active_index + 1;
     else if (index == -1)
       index = active_index;
   } else if (ShouldDragToPreviousStackedTab(dragged_bounds, active_index)) {
     index = active_index - 1;
   }
   return index;
@@ skipping 513 matching lines @@
        it != browser_list->end(); ++it) {
     if ((*it)->tab_strip_model()->empty())
       exclude.insert((*it)->window()->GetNativeWindow());
   }
 #endif
   return GetLocalProcessWindowAtPoint(host_desktop_type_,
                                       screen_point,
                                       exclude);
 
 }