Rework tree APIs to reflect Google style and more const-correctness....

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>
-#ifndef NDEBUG
-#include <iostream>
-#endif
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/path.h"
 #include "views/background.h"
@@ skipping 53 matching lines @@
       next_focusable_view_(NULL),
       previous_focusable_view_(NULL),
       context_menu_controller_(NULL),
       drag_controller_(NULL) {
 }
 
 View::~View() {
   if (parent_)
     parent_->RemoveChildView(this);
 
-  int c = static_cast<int>(child_views_.size());
+  int c = static_cast<int>(children_.size());
   while (--c >= 0) {
-    child_views_[c]->SetParent(NULL);
-    if (child_views_[c]->IsParentOwned())
-      delete child_views_[c];
+    children_[c]->SetParent(NULL);
+    if (children_[c]->IsParentOwned())
+      delete children_[c];
   }
 
 #if defined(OS_WIN)
   if (view_accessibility_.get())
     view_accessibility_->set_view(NULL);
 #endif
 }
 
 // Tree operations -------------------------------------------------------------
 
-void View::AddChildView(View* v) {
-  AddChildView(static_cast<int>(child_views_.size()), v);
-}
-
-void View::AddChildView(int index, View* v) {
-  CHECK(v != this) << "You cannot add a view as its own child";
-
-  // Remove the view from its current parent if any.
-  if (v->GetParent())
-    v->GetParent()->RemoveChildView(v);
-
-  // Sets the prev/next focus views.
-  InitFocusSiblings(v, index);
-
-  // Let's insert the view.
-  child_views_.insert(child_views_.begin() + index, v);
-  v->SetParent(this);
-
-  for (View* p = this; p; p = p->GetParent())
-    p->ViewHierarchyChangedImpl(false, true, this, v);
-
-  v->PropagateAddNotifications(this, v);
-  UpdateTooltip();
-  RootView* root = GetRootView();
-  if (root)
-    RegisterChildrenForVisibleBoundsNotification(root, v);
-
-  if (layout_manager_.get())
-    layout_manager_->ViewAdded(this, v);
-}
-
-View* View::GetChildViewAt(int index) const {
-  return index < GetChildViewCount() ? child_views_[index] : NULL;
-}
-
-void View::RemoveChildView(View* a_view) {
-  DoRemoveChildView(a_view, true, true, false);
-}
-
-void View::RemoveAllChildViews(bool delete_views) {
-  ViewList::iterator iter;
-  while ((iter = child_views_.begin()) != child_views_.end()) {
-    DoRemoveChildView(*iter, false, false, delete_views);
-  }
-  UpdateTooltip();
-}
-
-int View::GetChildViewCount() const {
-  return static_cast<int>(child_views_.size());
-}
-
-bool View::HasChildView(View* a_view) {
-  return find(child_views_.begin(),
-    child_views_.end(),
-    a_view) != child_views_.end();
-}
-
-Widget* View::GetWidget() const {
+const Widget* View::GetWidget() const {
   // The root view holds a reference to this view hierarchy's Widget.
   return parent_ ? parent_->GetWidget() : NULL;
 }
 
-Window* View::GetWindow() const {
-  Widget* widget = GetWidget();
+Widget* View::GetWidget() {
+  return const_cast<Widget*>(const_cast<const View*>(this)->GetWidget());
+}
+
+void View::AddChildView(View* view) {
+  AddChildViewAt(view, child_count());
+}
+
+void View::AddChildViewAt(View* view, int index) {
+  CHECK(view != this) << "You cannot add a view as its own child";
+
+  // Remove the view from its current parent if any.
+  if (view->parent())
+    view->parent()->RemoveChildView(view);
+
+  // Sets the prev/next focus views.
+  InitFocusSiblings(view, index);
+
+  // Let's insert the view.
+  children_.insert(children_.begin() + index, view);
+  view->SetParent(this);
+
+  for (View* p = this; p; p = p->parent())
+    p->ViewHierarchyChangedImpl(false, true, this, view);
+
+  view->PropagateAddNotifications(this, view);
+  UpdateTooltip();
+  RootView* root = GetRootView();
+  if (root)
+    RegisterChildrenForVisibleBoundsNotification(root, view);
+
+  if (layout_manager_.get())
+    layout_manager_->ViewAdded(this, view);
+}
+
+void View::RemoveChildView(View* view) {
+  DoRemoveChildView(view, true, true, false);
+}
+
+void View::RemoveAllChildViews(bool delete_views) {
+  ViewVector::iterator iter;
+  while ((iter = children_.begin()) != children_.end())
+    DoRemoveChildView(*iter, false, false, delete_views);
+  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 {
+  const View* child = view;
+  while (child) {
+    if (child == this)
+      return true;
+    child = child->parent();
+  }
+  return false;
+}
+
+int View::GetIndexOf(const View* view) const {
+  ViewVector::const_iterator it = std::find(children_.begin(), children_.end(),
+                                            view);
+  return it != children_.end() ? it - children_.begin() : -1;
+}
+
+// TODO(beng): remove
+const Window* View::GetWindow() const {
+  const Widget* widget = GetWidget();
   return widget ? widget->GetWindow() : NULL;
 }
 
+// TODO(beng): remove
+Window* View::GetWindow() {
+  return const_cast<Window*>(const_cast<const View*>(this)->GetWindow());
+}
+
+// TODO(beng): remove
 bool View::ContainsNativeView(gfx::NativeView native_view) const {
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i) {
+  for (int i = 0, count = child_count(); i < count; ++i) {
     if (GetChildViewAt(i)->ContainsNativeView(native_view))
       return true;
   }
   return false;
 }
 
-// Get the containing RootView
+// TODO(beng): remove
 RootView* View::GetRootView() {
   Widget* widget = GetWidget();
   return widget ? widget->GetRootView() : NULL;
 }
 
-int View::GetChildIndex(const View* v) const {
-  for (int i = 0, count = GetChildViewCount(); i < count; i++) {
-    if (v == GetChildViewAt(i))
-      return i;
-  }
-  return -1;
-}
-
-bool View::IsParentOf(View* v) const {
-  DCHECK(v);
-  View* parent = v->GetParent();
-  while (parent) {
-    if (this == parent)
-      return true;
-    parent = parent->GetParent();
-  }
-  return false;
-}
-
 #ifndef NDEBUG
-void View::PrintViewHierarchy() {
-  PrintViewHierarchyImp(0);
-}
-
-void View::PrintFocusHierarchy() {
-  PrintFocusHierarchyImp(0);
-}
 #endif
 
 // Size and disposition --------------------------------------------------------
 
 void View::SetBounds(int x, int y, int width, int height) {
   SetBoundsRect(gfx::Rect(x, y, std::max(0, width), std::max(0, height)));
 }
 
 void View::SetBoundsRect(const gfx::Rect& bounds) {
   if (bounds == bounds_) {
@@ skipping 65 matching lines @@
     return gfx::Rect();
   gfx::Rect vis_bounds(0, 0, width(), height());
   gfx::Rect ancestor_bounds;
   View* view = this;
   int root_x = 0;
   int root_y = 0;
   while (view != NULL && !vis_bounds.IsEmpty()) {
     root_x += view->GetMirroredX();
     root_y += view->y();
     vis_bounds.Offset(view->GetMirroredX(), view->y());
-    View* ancestor = view->GetParent();
+    View* ancestor = view->parent();
     if (ancestor != NULL) {
       ancestor_bounds.SetRect(0, 0, ancestor->width(),
         ancestor->height());
       vis_bounds = vis_bounds.Intersect(ancestor_bounds);
     } else if (!view->GetWidget()) {
       // If the view has no Widget, we're not visible. Return an empty rect.
       return gfx::Rect();
     }
     view = ancestor;
   }
@@ skipping 38 matching lines @@
 
 void View::SetVisible(bool flag) {
   if (flag != is_visible_) {
     // If the tab is currently visible, schedule paint to
     // refresh parent
     if (IsVisible())
       SchedulePaint();
 
     is_visible_ = flag;
 
-    // This notifies all subviews recursively.
+    // This notifies all sub-views recursively.
     PropagateVisibilityNotifications(this, flag);
 
     // If we are newly visible, schedule paint.
     if (IsVisible())
       SchedulePaint();
   }
 }
 
 bool View::IsVisibleInRootView() const {
-  View* parent = GetParent();
-  if (IsVisible() && parent)
-    return parent->IsVisibleInRootView();
-  else
-    return false;
+  return IsVisible() && parent() ? parent()->IsVisibleInRootView() : false;
 }
 
 void View::SetEnabled(bool state) {
   if (enabled_ != state) {
     enabled_ = state;
     SchedulePaint();
   }
 }
 
 bool View::IsEnabled() const {
   return enabled_;
 }
 
 // RTL positioning -------------------------------------------------------------
 
 gfx::Rect View::GetMirroredBounds() const {
   gfx::Rect bounds(bounds_);
   bounds.set_x(GetMirroredX());
   return bounds;
 }
 
 gfx::Point View::GetMirroredPosition() const {
   return gfx::Point(GetMirroredX(), y());
 }
 
 int View::GetMirroredX() const {
-  View* parent = GetParent();
-  return parent ? parent->GetMirroredXForRect(bounds_) : x();
+  return parent() ? parent()->GetMirroredXForRect(bounds_) : x();
 }
 
 int View::GetMirroredXForRect(const gfx::Rect& bounds) const {
   return base::i18n::IsRTL() ?
       (width() - bounds.x() - bounds.width()) : bounds.x();
 }
 
 int View::GetMirroredXInView(int x) const {
   return base::i18n::IsRTL() ? width() - x : x;
 }
@@ skipping 12 matching lines @@
     layout_manager_->Layout(this);
     SchedulePaint();
   }
 
   // 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 = GetChildViewCount(); i < count; ++i) {
+  for (int i = 0, count = child_count(); i < count; ++i) {
     View* child = GetChildViewAt(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
@@ skipping 16 matching lines @@
     layout_manager_->Installed(this);
 }
 
 // Attributes ------------------------------------------------------------------
 
 std::string View::GetClassName() const {
   return kViewClassName;
 }
 
 View* View::GetAncestorWithClassName(const std::string& name) {
-  for (View* view = this; view; view = view->GetParent()) {
+  for (View* view = this; view; view = view->parent()) {
     if (view->GetClassName() == name)
       return view;
   }
   return NULL;
 }
 
-View* View::GetViewByID(int id) const {
+const View* View::GetViewByID(int id) const {
   if (id == id_)
     return const_cast<View*>(this);
 
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i) {
-    View* child = GetChildViewAt(i);
-    View* view = child->GetViewByID(id);
+  for (int i = 0, count = child_count(); i < count; ++i) {
+    const View* view = GetChildViewAt(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::SetID(int id) {
   id_ = id;
 }
 
 int View::GetID() const {
   return 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_;
 }
 
 void View::GetViewsWithGroup(int group_id, std::vector<View*>* out) {
   if (group_ == group_id)
     out->push_back(this);
 
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i)
+  for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->GetViewsWithGroup(group_id, out);
 }
 
 View* View::GetSelectedViewForGroup(int group_id) {
   std::vector<View*> views;
   GetRootView()->GetViewsWithGroup(group_id, &views);
   if (views.size() > 0)
     return views[0];
   else
     return NULL;
 }
 
 // Coordinate conversion -------------------------------------------------------
 
 // static
 void View::ConvertPointToView(const View* src,
                               const View* dst,
                               gfx::Point* point) {
   ConvertPointToView(src, dst, point, true);
 }
 
 // static
 void View::ConvertPointToWidget(const View* src, gfx::Point* p) {
   DCHECK(src);
   DCHECK(p);
 
   gfx::Point offset;
-  for (const View* v = src; v; v = v->GetParent()) {
+  for (const View* v = src; v; v = v->parent()) {
     offset.set_x(offset.x() + v->GetMirroredX());
     offset.set_y(offset.y() + v->y());
   }
   p->SetPoint(p->x() + offset.x(), p->y() + offset.y());
 }
 
 // static
 void View::ConvertPointFromWidget(const View* dest, gfx::Point* p) {
   gfx::Point t;
   ConvertPointToWidget(dest, &t);
   p->SetPoint(p->x() - t.x(), p->y() - t.y());
 }
 
 // static
 void View::ConvertPointToScreen(const View* src, gfx::Point* p) {
   DCHECK(src);
   DCHECK(p);
 
   // If the view is not connected to a tree, there's nothing we can do.
-  Widget* widget = src->GetWidget();
+  const Widget* widget = src->GetWidget();
   if (widget) {
     ConvertPointToWidget(src, p);
     gfx::Rect r;
     widget->GetBounds(&r, false);
     p->SetPoint(p->x() + r.x(), p->y() + r.y());
   }
 }
 
 // Painting --------------------------------------------------------------------
 
@@ skipping 32 matching lines @@
 
 void View::PaintFocusBorder(gfx::Canvas* canvas) {
   if (HasFocus() && (IsFocusable() || IsAccessibilityFocusableInRootView()))
     canvas->DrawFocusRect(0, 0, width(), height());
 }
 
 void View::PaintNow() {
   if (!IsVisible())
     return;
 
-  View* view = GetParent();
-  if (view)
-    view->PaintNow();
+  if (parent())
+    parent()->PaintNow();
 }
 
 void View::ProcessPaint(gfx::Canvas* canvas) {
   if (!IsVisible())
     return;
 
   // We're going to modify the canvas, save it's state first.
   canvas->Save();
 
   // Paint this View and its children, setting the clip rect to the bounds
@@ skipping 24 matching lines @@
     canvas->Restore();
 
     PaintChildren(canvas);
   }
 
   // Restore the canvas's original transform.
   canvas->Restore();
 }
 
 void View::PaintChildren(gfx::Canvas* canvas) {
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i) {
+  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->ProcessPaint(canvas);
   }
 }
 
 ThemeProvider* View::GetThemeProvider() const {
-  Widget* widget = GetWidget();
+  const Widget* widget = GetWidget();
   return widget ? widget->GetThemeProvider() : NULL;
 }
 
 // Input -----------------------------------------------------------------------
 
 View* View::GetViewForPoint(const gfx::Point& point) {
   // Walk the child Views recursively looking for the View that most
   // tightly encloses the specified point.
-  for (int i = GetChildViewCount() - 1; i >= 0; --i) {
+  for (int i = child_count() - 1; i >= 0; --i) {
     View* child = GetChildViewAt(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->GetViewForPoint(point_in_child_coords);
   }
   return this;
@@ skipping 128 matching lines @@
   FocusManager* focus_manager = GetFocusManager();
   if (focus_manager)
     return focus_manager->GetFocusedView() == this;
   return false;
 }
 
 View* View::GetNextFocusableView() {
   return next_focusable_view_;
 }
 
+const View* View::GetNextFocusableView() const {
+  return next_focusable_view_;
+}
+
 View* View::GetPreviousFocusableView() {
   return previous_focusable_view_;
 }
 
 void View::SetNextFocusableView(View* view) {
   view->previous_focusable_view_ = this;
   next_focusable_view_ = view;
 }
 
 void View::SetFocusable(bool focusable) {
@@ skipping 116 matching lines @@
   return AccessibilityTypes::ROLE_CLIENT;
 }
 
 void View::SetAccessibleName(const string16& name) {
   accessible_name_ = name;
 }
 
 // Scrolling -------------------------------------------------------------------
 
 void View::ScrollRectToVisible(const gfx::Rect& rect) {
-  View* parent = GetParent();
-
   // We must take RTL UI mirroring into account when adjusting the position of
   // the region.
-  if (parent) {
+  if (parent()) {
     gfx::Rect scroll_rect(rect);
     scroll_rect.Offset(GetMirroredX(), y());
-    parent->ScrollRectToVisible(scroll_rect);
+    parent()->ScrollRectToVisible(scroll_rect);
   }
 }
 
 int View::GetPageScrollIncrement(ScrollView* scroll_view,
                                  bool is_horizontal, bool is_positive) {
   return 0;
 }
 
 int View::GetLineScrollIncrement(ScrollView* scroll_view,
                                  bool is_horizontal, bool is_positive) {
@@ skipping 51 matching lines @@
       RegisterPendingAccelerators();
       accelerator_registration_delayed_ = false;
     }
   }
 }
 
 // Painting --------------------------------------------------------------------
 
 #ifndef NDEBUG
 bool View::IsProcessingPaint() const {
-  return GetParent() && GetParent()->IsProcessingPaint();
+  return parent() && parent()->IsProcessingPaint();
 }
 #endif
 
 // Input -----------------------------------------------------------------------
 
 bool View::HasHitTestMask() const {
   return false;
 }
 
 void View::GetHitTestMask(gfx::Path* mask) const {
@@ skipping 66 matching lines @@
   start_pt = gfx::Point();
 }
 
 void View::DragInfo::PossibleDrag(const gfx::Point& p) {
   possible_drag = true;
   start_pt = p;
 }
 
 // Tree operations -------------------------------------------------------------
 
-void View::DoRemoveChildView(View* a_view,
+void View::DoRemoveChildView(View* view,
                              bool update_focus_cycle,
                              bool update_tool_tip,
                              bool delete_removed_view) {
 #ifndef NDEBUG
   DCHECK(!IsProcessingPaint()) << "Should not be removing a child view " <<
                                   "during a paint, this will seriously " <<
                                   "mess things up!";
 #endif
-  DCHECK(a_view);
-  const ViewList::iterator i =  find(child_views_.begin(),
-                                     child_views_.end(),
-                                     a_view);
+  DCHECK(view);
+  const ViewVector::iterator i = find(children_.begin(), children_.end(), view);
   scoped_ptr<View> view_to_be_deleted;
-  if (i != child_views_.end()) {
+  if (i != children_.end()) {
     if (update_focus_cycle) {
       // Let's remove the view from the focus traversal.
-      View* next_focusable = a_view->next_focusable_view_;
-      View* prev_focusable = a_view->previous_focusable_view_;
+      View* next_focusable = view->next_focusable_view_;
+      View* prev_focusable = view->previous_focusable_view_;
       if (prev_focusable)
         prev_focusable->next_focusable_view_ = next_focusable;
       if (next_focusable)
         next_focusable->previous_focusable_view_ = prev_focusable;
     }
 
     RootView* root = GetRootView();
     if (root)
-      UnregisterChildrenForVisibleBoundsNotification(root, a_view);
-    a_view->PropagateRemoveNotifications(this);
-    a_view->SetParent(NULL);
+      UnregisterChildrenForVisibleBoundsNotification(root, view);
+    view->PropagateRemoveNotifications(this);
+    view->SetParent(NULL);
 
-    if (delete_removed_view && a_view->IsParentOwned())
-      view_to_be_deleted.reset(a_view);
+    if (delete_removed_view && view->IsParentOwned())
+      view_to_be_deleted.reset(view);
 
-    child_views_.erase(i);
+    children_.erase(i);
   }
 
   if (update_tool_tip)
     UpdateTooltip();
 
   if (layout_manager_.get())
-    layout_manager_->ViewRemoved(this, a_view);
+    layout_manager_->ViewRemoved(this, view);
 }
 
 void View::SetParent(View* parent) {
   if (parent != parent_)
     parent_ = parent;
 }
 
 void View::PropagateRemoveNotifications(View* parent) {
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i)
+  for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->PropagateRemoveNotifications(parent);
 
-  for (View* v = this; v; v = v->GetParent())
+  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 = GetChildViewCount(); i < count; ++i)
+  for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->PropagateAddNotifications(parent, child);
   ViewHierarchyChangedImpl(true, true, parent, child);
 }
 
 void View::PropagateNativeViewHierarchyChanged(bool attached,
                                                gfx::NativeView native_view,
                                                RootView* root_view) {
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i)
+  for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(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) {
@@ skipping 11 matching lines @@
     } else {
       if (child == this)
         UnregisterAccelerators(true);
     }
   }
 
   ViewHierarchyChanged(is_add, parent, child);
   parent->needs_layout_ = true;
 }
 
-#ifndef NDEBUG
-void View::PrintViewHierarchyImp(int indent) {
-  std::wostringstream buf;
-  int ind = indent;
-  while (ind-- > 0)
-    buf << L' ';
-  buf << UTF8ToWide(GetClassName());
-  buf << L' ';
-  buf << GetID();
-  buf << L' ';
-  buf << bounds_.x() << L"," << bounds_.y() << L",";
-  buf << bounds_.right() << L"," << bounds_.bottom();
-  buf << L' ';
-  buf << this;
-
-  VLOG(1) << buf.str();
-  std::cout << buf.str() << std::endl;
-
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i)
-    GetChildViewAt(i)->PrintViewHierarchyImp(indent + 2);
-}
-
-void View::PrintFocusHierarchyImp(int indent) {
-  std::wostringstream buf;
-  int ind = indent;
-  while (ind-- > 0)
-    buf << L' ';
-  buf << UTF8ToWide(GetClassName());
-  buf << L' ';
-  buf << GetID();
-  buf << L' ';
-  buf << GetClassName().c_str();
-  buf << L' ';
-  buf << this;
-
-  VLOG(1) << buf.str();
-  std::cout << buf.str() << std::endl;
-
-  if (GetChildViewCount() > 0)
-    GetChildViewAt(0)->PrintFocusHierarchyImp(indent + 2);
-
-  View* v = GetNextFocusableView();
-  if (v)
-    v->PrintFocusHierarchyImp(indent);
-}
-#endif
-
 // Size and disposition --------------------------------------------------------
 
 void View::PropagateVisibilityNotifications(View* start, bool is_visible) {
-  for (int i = 0, count = GetChildViewCount(); i < count; ++i)
+  for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(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);
 }
 
 // static
 void View::RegisterChildrenForVisibleBoundsNotification(
     RootView* root, View* view) {
   DCHECK(root && view);
   if (view->GetNotifyWhenVisibleBoundsInRootChanges())
     root->RegisterViewForVisibleBoundsNotification(view);
-  for (int i = 0; i < view->GetChildViewCount(); ++i)
+  for (int i = 0; i < view->child_count(); ++i)
     RegisterChildrenForVisibleBoundsNotification(root, view->GetChildViewAt(i));
 }
 
 // static
 void View::UnregisterChildrenForVisibleBoundsNotification(
     RootView* root, View* view) {
   DCHECK(root && view);
   if (view->GetNotifyWhenVisibleBoundsInRootChanges())
     root->UnregisterViewForVisibleBoundsNotification(view);
-  for (int i = 0; i < view->GetChildViewCount(); ++i)
+  for (int i = 0; i < view->child_count(); ++i)
     UnregisterChildrenForVisibleBoundsNotification(root,
                                                    view->GetChildViewAt(i));
 }
 
 void View::AddDescendantToNotify(View* view) {
   DCHECK(view);
   if (!descendants_to_notify_.get())
-    descendants_to_notify_.reset(new ViewList());
+    descendants_to_notify_.reset(new ViewVector);
   descendants_to_notify_->push_back(view);
 }
 
 void View::RemoveDescendantToNotify(View* view) {
   DCHECK(view && descendants_to_notify_.get());
-  ViewList::iterator i = find(descendants_to_notify_->begin(),
-                              descendants_to_notify_->end(),
-                              view);
+  ViewVector::iterator i = find(descendants_to_notify_->begin(),
+                                descendants_to_notify_->end(),
+                                view);
   DCHECK(i != descendants_to_notify_->end());
   descendants_to_notify_->erase(i);
   if (descendants_to_notify_->empty())
     descendants_to_notify_.reset();
 }
 
 // Coordinate conversion -------------------------------------------------------
 
 // static
 void View::ConvertPointToView(const View* src,
                               const View* dst,
                               gfx::Point* point,
                               bool try_other_direction) {
   // src can be NULL
   DCHECK(dst);
   DCHECK(point);
 
   const View* v;
   gfx::Point offset;
 
-  for (v = dst; v && v != src; v = v->GetParent())
+  for (v = dst; v && v != src; v = v->parent())
     offset.SetPoint(offset.x() + v->GetMirroredX(), offset.y() + v->y());
 
   // The source was not found. The caller wants a conversion
   // from a view to a transitive parent.
   if (src && v == NULL && try_other_direction) {
     gfx::Point p;
     // note: try_other_direction is force to FALSE so we don't
     // end up in an infinite recursion should both src and dst
     // are not parented.
     ConvertPointToView(dst, src, &p, false);
     // since the src and dst are inverted, p should also be negated
     point->SetPoint(point->x() - p.x(), point->y() - p.y());
   } else {
     point->SetPoint(point->x() - offset.x(), point->y() - offset.y());
 
     // If src is NULL, sp is in the screen coordinate system
     if (src == NULL) {
-      Widget* widget = dst->GetWidget();
+      const Widget* widget = dst->GetWidget();
       if (widget) {
         gfx::Rect b;
         widget->GetBounds(&b, false);
         point->SetPoint(point->x() - b.x(), point->y() - b.y());
       }
     }
   }
 }
 
 // Input -----------------------------------------------------------------------
@@ skipping 120 matching lines @@
       accelerators_->clear();
       accelerators_.reset();
     }
     registered_accelerator_count_ = 0;
   }
 }
 
 // Focus -----------------------------------------------------------------------
 
 void View::InitFocusSiblings(View* v, int index) {
-  int child_count = static_cast<int>(child_views_.size());
+  int child_count = static_cast<int>(children_.size());
 
   if (child_count == 0) {
     v->next_focusable_view_ = NULL;
     v->previous_focusable_view_ = NULL;
   } else {
     if (index == child_count) {
       // We are inserting at the end, but the end of the child list may not be
       // the last focusable element. Let's try to find an element with no next
       // focusable element to link to.
       View* last_focusable_view = NULL;
-      for (std::vector<View*>::iterator iter = child_views_.begin();
-           iter != child_views_.end(); ++iter) {
+      for (std::vector<View*>::iterator iter = children_.begin();
+           iter != children_.end(); ++iter) {
           if (!(*iter)->next_focusable_view_) {
             last_focusable_view = *iter;
             break;
           }
       }
       if (last_focusable_view == NULL) {
         // Hum... there is a cycle in the focus list. Let's just insert ourself
         // after the last child.
-        View* prev = child_views_[index - 1];
+        View* prev = children_[index - 1];
         v->previous_focusable_view_ = prev;
         v->next_focusable_view_ = prev->next_focusable_view_;
         prev->next_focusable_view_->previous_focusable_view_ = v;
         prev->next_focusable_view_ = v;
       } else {
         last_focusable_view->next_focusable_view_ = v;
         v->next_focusable_view_ = NULL;
         v->previous_focusable_view_ = last_focusable_view;
       }
     } else {
-      View* prev = child_views_[index]->GetPreviousFocusableView();
+      View* prev = children_[index]->GetPreviousFocusableView();
       v->previous_focusable_view_ = prev;
-      v->next_focusable_view_ = child_views_[index];
+      v->next_focusable_view_ = children_[index];
       if (prev)
         prev->next_focusable_view_ = v;
-      child_views_[index]->previous_focusable_view_ = v;
+      children_[index]->previous_focusable_view_ = v;
     }
   }
 }
 
 // System events ---------------------------------------------------------------
 
 void View::PropagateThemeChanged() {
-  for (int i = GetChildViewCount() - 1; i >= 0; --i)
+  for (int i = child_count() - 1; i >= 0; --i)
     GetChildViewAt(i)->PropagateThemeChanged();
   OnThemeChanged();
 }
 
 void View::PropagateLocaleChanged() {
-  for (int i = GetChildViewCount() - 1; i >= 0; --i)
+  for (int i = child_count() - 1; i >= 0; --i)
     GetChildViewAt(i)->PropagateLocaleChanged();
   OnLocaleChanged();
 }
 
 // Tooltips --------------------------------------------------------------------
 
 void View::UpdateTooltip() {
   Widget* widget = GetWidget();
   if (widget && widget->GetTooltipManager())
     widget->GetTooltipManager()->UpdateTooltip();
 }
 
 // Drag and drop ---------------------------------------------------------------
 
 void View::DoDrag(const MouseEvent& e, const gfx::Point& press_pt) {
   int drag_operations = GetDragOperations(press_pt);
   if (drag_operations == ui::DragDropTypes::DRAG_NONE)
     return;
 
   OSExchangeData data;
   WriteDragData(press_pt, &data);
 
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   RootView* root_view = GetRootView();
   root_view->StartDragForViewFromMouseEvent(this, data, drag_operations);
 }
 
 }  // namespace views