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

views/widget/root_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/widget/root_view.h"
 
 #include <algorithm>
 
 #if defined(TOUCH_UI) && defined(HAVE_XINPUT2)
 #include <gdk/gdkx.h>
@@ skipping 86 matching lines @@
 #ifndef NDEBUG
       ,
       is_processing_paint_(false)
 #endif
 {
 }
 
 RootView::~RootView() {
   // If we have children remove them explicitly so to make sure a remove
   // notification is sent for each one of them.
-  if (!child_views_.empty())
+  if (has_children())
     RemoveAllChildViews(true);
 
   if (pending_paint_task_)
     pending_paint_task_->Cancel();  // Ensure we're not called any more.
 }
 
 void RootView::SetContentsView(View* contents_view) {
   DCHECK(contents_view && GetWidget()->GetNativeView()) <<
       "Can't be called until after the native view is created!";
   // The ContentsView must be set up _after_ the window is created so that its
   // Widget pointer is valid.
   SetLayoutManager(new FillLayout);
-  if (GetChildViewCount() != 0)
+  if (has_children())
     RemoveAllChildViews(true);
   AddChildView(contents_view);
 
   // Force a layout now, since the attached hierarchy won't be ready for the
   // containing window's bounds. Note that we call Layout directly rather than
   // calling the widget's size changed handler, since the RootView's bounds may
   // not have changed, which will cause the Layout not to be done otherwise.
   Layout();
 }
 
@@ skipping 114 matching lines @@
 
   return invalid_rect_.Intersect(GetContentsBounds());
 }
 
 /////////////////////////////////////////////////////////////////////////////
 //
 // RootView - tree
 //
 /////////////////////////////////////////////////////////////////////////////
 
-Widget* RootView::GetWidget() const {
+const Widget* RootView::GetWidget() const {
   return widget_;
 }
 
+Widget* RootView::GetWidget() {
+  return const_cast<Widget*>(const_cast<const RootView*>(this)->GetWidget());
+}
+
 void RootView::NotifyThemeChanged() {
   View::PropagateThemeChanged();
 }
 
 void RootView::NotifyLocaleChanged() {
   View::PropagateLocaleChanged();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 //
@@ skipping 56 matching lines @@
     status = touch_pressed_handler_->ProcessTouchEvent(touch_event);
     gesture_manager_->ProcessTouchEventForGesture(e, this, status);
     if (status == TOUCH_STATUS_END)
       touch_pressed_handler_ = NULL;
     return status;
   }
 
   // Walk up the tree until we find a view that wants the touch event.
   for (touch_pressed_handler_ = GetViewForPoint(e.location());
        touch_pressed_handler_ && (touch_pressed_handler_ != this);
-       touch_pressed_handler_ = touch_pressed_handler_->GetParent()) {
+       touch_pressed_handler_ = touch_pressed_handler_->parent()) {
     if (!touch_pressed_handler_->IsEnabled()) {
       // Disabled views eat events but are treated as not handled by the
       // the GestureManager.
       status = TOUCH_STATUS_UNKNOWN;
       break;
     }
 
     // See if this view wants to handle the touch
     TouchEvent touch_event(e, this, touch_pressed_handler_);
     status = touch_pressed_handler_->ProcessTouchEvent(touch_event);
@@ skipping 54 matching lines @@
     mouse_pressed_handler_->ProcessMousePressed(mouse_pressed_event,
                                                 &drag_info);
     return true;
   }
   DCHECK(!explicit_mouse_handler_);
 
   bool hit_disabled_view = false;
   // Walk up the tree until we find a view that wants the mouse event.
   for (mouse_pressed_handler_ = GetViewForPoint(e.location());
        mouse_pressed_handler_ && (mouse_pressed_handler_ != this);
-       mouse_pressed_handler_ = mouse_pressed_handler_->GetParent()) {
+       mouse_pressed_handler_ = mouse_pressed_handler_->parent()) {
     if (!mouse_pressed_handler_->IsEnabled()) {
       // Disabled views should eat events instead of propagating them upwards.
       hit_disabled_view = true;
       break;
     }
 
     // See if this view wants to handle the mouse press.
     MouseEvent mouse_pressed_event(e, this, mouse_pressed_handler_);
 
     // Remove the double-click flag if the handler is different than the
@@ skipping 119 matching lines @@
   }
 }
 
 void RootView::OnMouseMoved(const MouseEvent& e) {
   View* v = GetViewForPoint(e.location());
   // Find the first enabled view, or the existing move handler, whichever comes
   // first.  The check for the existing handler is because if a view becomes
   // disabled while handling moves, it's wrong to suddenly send ET_MOUSE_EXITED
   // and ET_MOUSE_ENTERED events, because the mouse hasn't actually exited yet.
   while (v && !v->IsEnabled() && (v != mouse_move_handler_))
-    v = v->GetParent();
+    v = v->parent();
   if (v && v != this) {
     if (v != mouse_move_handler_) {
       if (mouse_move_handler_ != NULL) {
         MouseEvent exited_event(Event::ET_MOUSE_EXITED, 0, 0, 0);
         mouse_move_handler_->OnMouseExited(exited_event);
       }
 
       mouse_move_handler_ = v;
 
       MouseEvent entered_event(Event::ET_MOUSE_ENTERED,
@@ skipping 113 matching lines @@
   bool consumed = false;
 
   View* v = GetFocusedView();
   // Special case to handle right-click context menus triggered by the
   // keyboard.
   if (v && v->IsEnabled() && ((event.GetKeyCode() == ui::VKEY_APPS) ||
      (event.GetKeyCode() == ui::VKEY_F10 && event.IsShiftDown()))) {
     v->ShowContextMenu(v->GetKeyboardContextMenuLocation(), false);
     return true;
   }
-  for (; v && v != this && !consumed; v = v->GetParent()) {
+  for (; v && v != this && !consumed; v = v->parent()) {
     consumed = (event.GetType() == Event::ET_KEY_PRESSED) ?
         v->OnKeyPressed(event) : v->OnKeyReleased(event);
   }
 
   if (!consumed && default_keyboard_handler_) {
     consumed = (event.GetType() == Event::ET_KEY_PRESSED) ?
         default_keyboard_handler_->OnKeyPressed(event) :
         default_keyboard_handler_->OnKeyReleased(event);
   }
 
   return consumed;
 }
 
 bool RootView::ProcessMouseWheelEvent(const MouseWheelEvent& e) {
   View* v;
   bool consumed = false;
   if (GetFocusedView()) {
-    for (v = GetFocusedView();
-         v && v != this && !consumed; v = v->GetParent()) {
+    for (v = GetFocusedView(); v && v != this && !consumed; v = v->parent())
       consumed = v->OnMouseWheel(e);
-    }
   }
 
   if (!consumed && default_keyboard_handler_) {
     consumed = default_keyboard_handler_->OnMouseWheel(e);
   }
   return consumed;
 }
 
 void RootView::SetDefaultKeyboardHandler(View* v) {
   default_keyboard_handler_ = v;
@@ skipping 13 matching lines @@
        i != view->descendants_to_notify_->end(); ++i) {
     (*i)->VisibleBoundsInRootChanged();
   }
 }
 
 void RootView::RegisterViewForVisibleBoundsNotification(View* view) {
   DCHECK(view);
   if (view->registered_for_visible_bounds_notification_)
     return;
   view->registered_for_visible_bounds_notification_ = true;
-  View* ancestor = view->GetParent();
+  View* ancestor = view->parent();
   while (ancestor) {
     ancestor->AddDescendantToNotify(view);
-    ancestor = ancestor->GetParent();
+    ancestor = ancestor->parent();
   }
 }
 
 void RootView::UnregisterViewForVisibleBoundsNotification(View* view) {
   DCHECK(view);
   if (!view->registered_for_visible_bounds_notification_)
     return;
   view->registered_for_visible_bounds_notification_ = false;
-  View* ancestor = view->GetParent();
+  View* ancestor = view->parent();
   while (ancestor) {
     ancestor->RemoveDescendantToNotify(view);
-    ancestor = ancestor->GetParent();
+    ancestor = ancestor->parent();
   }
 }
 
 void RootView::SetMouseLocationAndFlags(const MouseEvent& e) {
   last_mouse_event_flags_ = e.GetFlags();
   last_mouse_event_x_ = e.x();
   last_mouse_event_y_ = e.y();
 }
 
 std::string RootView::GetClassName() const {
@@ skipping 42 matching lines @@
   if (!TouchFactory::GetInstance()->is_cursor_visible()) {
     cursor = gfx::GetCursor(GDK_BLANK_CURSOR);
   }
 #endif
 
   gdk_window_set_cursor(native_view->window, cursor);
 #endif
 }
 
 }  // namespace views