Convert some more view methods to the ui/views style.

views/view.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 "views/view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 205 matching lines @@
 void View::RemoveChildView(View* view) {
   DoRemoveChildView(view, true, true, false);
 }
 
 void View::RemoveAllChildViews(bool delete_children) {
   while (!children_.empty())
     DoRemoveChildView(children_.front(), false, false, delete_children);
   UpdateTooltip();
 }
 
-const View* View::GetChildViewAt(int index) const {
-  return index < child_count() ? children_[index] : NULL;
-}
-
-View* View::GetChildViewAt(int index) {
-  return
-      const_cast<View*>(const_cast<const View*>(this)->GetChildViewAt(index));
-}
-
 bool View::Contains(const View* view) const {
   for (const View* v = view; v; v = v->parent_) {
     if (v == this)
       return true;
   }
   return false;
 }
 
 int View::GetIndexOf(const View* view) const {
   Views::const_iterator i(std::find(children_.begin(), children_.end(), view));
@@ skipping 288 matching lines @@
   if (layout_manager_.get())
     layout_manager_->Layout(this);
 
   // Make sure to propagate the Layout() call to any children that haven't
   // received it yet through the layout manager and need to be laid out. This
   // is needed for the case when the child requires a layout but its bounds
   // weren't changed by the layout manager. If there is no layout manager, we
   // just propagate the Layout() call down the hierarchy, so whoever receives
   // the call can take appropriate action.
   for (int i = 0, count = child_count(); i < count; ++i) {
-    View* child = GetChildViewAt(i);
+    View* child = child_at(i);
     if (child->needs_layout_ || !layout_manager_.get()) {
       child->needs_layout_ = false;
       child->Layout();
     }
   }
 }
 
 void View::InvalidateLayout() {
   // Always invalidate up. This is needed to handle the case of us already being
   // valid, but not our parent.
@@ skipping 27 matching lines @@
       return view;
   }
   return NULL;
 }
 
 const View* View::GetViewByID(int id) const {
   if (id == id_)
     return const_cast<View*>(this);
 
   for (int i = 0, count = child_count(); i < count; ++i) {
-    const View* view = GetChildViewAt(i)->GetViewByID(id);
+    const View* view = child_at(i)->GetViewByID(id);
     if (view)
       return view;
   }
   return NULL;
 }
 
 View* View::GetViewByID(int id) {
   return const_cast<View*>(const_cast<const View*>(this)->GetViewByID(id));
 }
 
 void View::SetGroup(int gid) {
   // Don't change the group id once it's set.
   DCHECK(group_ == -1 || group_ == gid);
   group_ = gid;
 }
 
 int View::GetGroup() const {
   return group_;
 }
 
 bool View::IsGroupFocusTraversable() const {
   return true;
 }
 
 void View::GetViewsInGroup(int group, Views* views) {
   if (group_ == group)
     views->push_back(this);
 
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->GetViewsInGroup(group, views);
+    child_at(i)->GetViewsInGroup(group, views);
 }
 
 View* View::GetSelectedViewForGroup(int group) {
   Views views;
   GetWidget()->GetRootView()->GetViewsInGroup(group, &views);
   return views.empty() ? NULL : views[0];
 }
 
 // Coordinate conversion -------------------------------------------------------
 
@@ skipping 162 matching lines @@
 bool View::get_use_acceleration_when_possible() {
   return use_acceleration_when_possible;
 }
 
 // Input -----------------------------------------------------------------------
 
 View* View::GetEventHandlerForPoint(const gfx::Point& point) {
   // Walk the child Views recursively looking for the View that most
   // tightly encloses the specified point.
   for (int i = child_count() - 1; i >= 0; --i) {
-    View* child = GetChildViewAt(i);
+    View* child = child_at(i);
     if (!child->IsVisible())
       continue;
 
     gfx::Point point_in_child_coords(point);
     View::ConvertPointToView(this, child, &point_in_child_coords);
     if (child->HitTest(point_in_child_coords))
       return child->GetEventHandlerForPoint(point_in_child_coords);
   }
   return this;
 }
@@ skipping 315 matching lines @@
     if (focus_manager) {
       RegisterPendingAccelerators();
       accelerator_registration_delayed_ = false;
     }
   }
 }
 
 // Painting --------------------------------------------------------------------
 
 void View::PaintChildren(gfx::Canvas* canvas) {
-  for (int i = 0, count = child_count(); i < count; ++i) {
-    View* child = GetChildViewAt(i);
-    if (!child) {
-      NOTREACHED() << "Should not have a NULL child View for index in bounds";
-      continue;
-    }
-    child->Paint(canvas);
-  }
+  for (int i = 0, count = child_count(); i < count; ++i)
+    child_at(i)->Paint(canvas);
 }
 
 void View::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
   OnPaintFocusBorder(canvas);
   OnPaintBorder(canvas);
 }
 
 void View::OnPaintBackground(gfx::Canvas* canvas) {
   if (background_.get())
@@ skipping 15 matching lines @@
 void View::PaintComposite() {
   if (!IsVisible())
     return;
 
   if (layer()) {
     OnWillCompositeLayer();
     layer()->Draw();
   }
 
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->PaintComposite();
+    child_at(i)->PaintComposite();
 }
 
 void View::SchedulePaintInternal(const gfx::Rect& rect) {
   if (parent_) {
     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
     parent_->SchedulePaintInternal(ConvertRectToParent(rect));
   }
 }
 
 void View::PaintToLayer(const gfx::Rect& dirty_region) {
   if (!IsVisible())
     return;
 
   if (layer() && layer_helper_->bitmap_needs_updating()) {
     if (!layer_helper_->needs_paint_all())
       layer_helper_->set_clip_rect(dirty_region);
     else
       layer_helper_->set_needs_paint_all(false);
     Paint(NULL);
     layer_helper_->set_clip_rect(gfx::Rect());
   } else {
     // Forward to all children as a descendant may be dirty and have a layer.
     for (int i = child_count() - 1; i >= 0; --i) {
-      View* child_view = GetChildViewAt(i);
+      View* child_view = child_at(i);
 
       gfx::Rect child_dirty_rect = dirty_region;
       child_dirty_rect.Offset(-child_view->GetMirroredX(), -child_view->y());
       child_view->GetTransform().TransformRectReverse(&child_dirty_rect);
       child_dirty_rect = gfx::Rect(gfx::Point(), child_view->size()).Intersect(
           child_dirty_rect);
 
       if (!child_dirty_rect.IsEmpty())
-        GetChildViewAt(i)->PaintToLayer(child_dirty_rect);
+        child_at(i)->PaintToLayer(child_dirty_rect);
     }
   }
 }
 
 void View::OnWillCompositeLayer() {
 }
 
 bool View::SetExternalTexture(ui::Texture* texture) {
   // A little heavy-handed -- it should be that each child has it's own layer.
   // The desired use case is where there are no children.
@@ skipping 57 matching lines @@
 
   offset->Offset(x(), y());
   parent_->CalculateOffsetToAncestorWithLayer(offset, ancestor);
 }
 
 void View::CreateLayerIfNecessary() {
   if (ShouldPaintToLayer())
     CreateLayer();
 
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->CreateLayerIfNecessary();
+    child_at(i)->CreateLayerIfNecessary();
 }
 
 void View::MoveLayerToParent(ui::Layer* parent_layer,
                              const gfx::Point& point) {
   gfx::Point local_point(point);
   if (parent_layer != layer())
     local_point.Offset(x(), y());
   if (layer() && parent_layer != layer()) {
     parent_layer->Add(layer());
     layer()->set_bounds(
         gfx::Rect(local_point.x(), local_point.y(), width(), height()));
   } else {
     for (int i = 0, count = child_count(); i < count; ++i)
-      GetChildViewAt(i)->MoveLayerToParent(parent_layer, local_point);
+      child_at(i)->MoveLayerToParent(parent_layer, local_point);
   }
 }
 
 void View::DestroyLayerRecurse() {
   for (int i = child_count() - 1; i >= 0; --i)
-    GetChildViewAt(i)->DestroyLayerRecurse();
+    child_at(i)->DestroyLayerRecurse();
   DestroyLayer();
 }
 
 void View::UpdateLayerBounds(const gfx::Point& offset) {
   if (layer()) {
     layer_helper_->property_setter()->SetBounds(
         layer(),
         gfx::Rect(offset.x() + x(), offset.y() + y(), width(), height()));
   } else {
     gfx::Point new_offset(offset.x() + x(), offset.y() + y());
     for (int i = 0, count = child_count(); i < count; ++i)
-      GetChildViewAt(i)->UpdateLayerBounds(new_offset);
+      child_at(i)->UpdateLayerBounds(new_offset);
   }
 }
 
 // Input -----------------------------------------------------------------------
 
 bool View::HasHitTestMask() const {
   return false;
 }
 
 void View::GetHitTestMask(gfx::Path* mask) const {
@@ skipping 137 matching lines @@
 
   if (update_tool_tip)
     UpdateTooltip();
 
   if (layout_manager_.get())
     layout_manager_->ViewRemoved(this, view);
 }
 
 void View::PropagateRemoveNotifications(View* parent) {
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->PropagateRemoveNotifications(parent);
+    child_at(i)->PropagateRemoveNotifications(parent);
 
   for (View* v = this; v; v = v->parent_)
     v->ViewHierarchyChangedImpl(true, false, parent, this);
 }
 
 void View::PropagateAddNotifications(View* parent, View* child) {
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->PropagateAddNotifications(parent, child);
+    child_at(i)->PropagateAddNotifications(parent, child);
   ViewHierarchyChangedImpl(true, true, parent, child);
 }
 
 void View::PropagateNativeViewHierarchyChanged(bool attached,
                                                gfx::NativeView native_view,
                                                internal::RootView* root_view) {
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->PropagateNativeViewHierarchyChanged(attached,
+    child_at(i)->PropagateNativeViewHierarchyChanged(attached,
                                                            native_view,
                                                            root_view);
   NativeViewHierarchyChanged(attached, native_view, root_view);
 }
 
 void View::ViewHierarchyChangedImpl(bool register_accelerators,
                                     bool is_add,
                                     View* parent,
                                     View* child) {
   if (register_accelerators) {
@@ skipping 14 matching lines @@
   }
 
   ViewHierarchyChanged(is_add, parent, child);
   parent->needs_layout_ = true;
 }
 
 // Size and disposition --------------------------------------------------------
 
 void View::PropagateVisibilityNotifications(View* start, bool is_visible) {
   for (int i = 0, count = child_count(); i < count; ++i)
-    GetChildViewAt(i)->PropagateVisibilityNotifications(start, is_visible);
+    child_at(i)->PropagateVisibilityNotifications(start, is_visible);
   VisibilityChangedImpl(start, is_visible);
 }
 
 void View::VisibilityChangedImpl(View* starting_from, bool is_visible) {
   if (is_visible)
     RegisterPendingAccelerators();
   else
     UnregisterAccelerators(true);
   VisibilityChanged(starting_from, is_visible);
 }
@@ skipping 54 matching lines @@
       (*i)->OnVisibleBoundsChanged();
     }
   }
 }
 
 // static
 void View::RegisterChildrenForVisibleBoundsNotification(View* view) {
   if (view->NeedsNotificationWhenVisibleBoundsChange())
     view->RegisterForVisibleBoundsNotification();
   for (int i = 0; i < view->child_count(); ++i)
-    RegisterChildrenForVisibleBoundsNotification(view->GetChildViewAt(i));
+    RegisterChildrenForVisibleBoundsNotification(view->child_at(i));
 }
 
 // static
 void View::UnregisterChildrenForVisibleBoundsNotification(View* view) {
   if (view->NeedsNotificationWhenVisibleBoundsChange())
     view->UnregisterForVisibleBoundsNotification();
   for (int i = 0; i < view->child_count(); ++i)
-    UnregisterChildrenForVisibleBoundsNotification(view->GetChildViewAt(i));
+    UnregisterChildrenForVisibleBoundsNotification(view->child_at(i));
 }
 
 void View::RegisterForVisibleBoundsNotification() {
   if (registered_for_visible_bounds_notification_)
     return;
 
   registered_for_visible_bounds_notification_ = true;
   for (View* ancestor = parent_; ancestor; ancestor = ancestor->parent_)
     ancestor->AddDescendantToNotify(this);
 }
@@ skipping 321 matching lines @@
         prev->next_focusable_view_ = v;
       children_[index]->previous_focusable_view_ = v;
     }
   }
 }
 
 // System events ---------------------------------------------------------------
 
 void View::PropagateThemeChanged() {
   for (int i = child_count() - 1; i >= 0; --i)
-    GetChildViewAt(i)->PropagateThemeChanged();
+    child_at(i)->PropagateThemeChanged();
   OnThemeChanged();
 }
 
 void View::PropagateLocaleChanged() {
   for (int i = child_count() - 1; i >= 0; --i)
-    GetChildViewAt(i)->PropagateLocaleChanged();
+    child_at(i)->PropagateLocaleChanged();
   OnLocaleChanged();
 }
 
 // Tooltips --------------------------------------------------------------------
 
 void View::UpdateTooltip() {
   Widget* widget = GetWidget();
   // TODO(beng): The TooltipManager NULL check can be removed when we
   //             consolidate Init() methods and make views_unittests Init() all
   //             Widgets that it uses.
@@ skipping 57 matching lines @@
     snprintf(pp, kMaxPointerStringLength, "%p", parent_);
     result.append("  N");
     result.append(pp+2);
     result.append(" -> N");
     result.append(p+2);
     result.append("\n");
   }
 
   // Children.
   for (int i = 0, count = child_count(); i < count; ++i)
-    result.append(GetChildViewAt(i)->PrintViewGraph(false));
+    result.append(child_at(i)->PrintViewGraph(false));
 
   if (first)
     result.append("}\n");
 
   return result;
 }
 #endif
 
 }  // namespace views