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

views/controls/single_split_view.cc

 // Copyright (c) 2010 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/controls/single_split_view.h"
 
 #if defined(OS_LINUX)
 #include <gdk/gdk.h>
 #endif
 
@@ skipping 21 matching lines @@
   AddChildView(leading);
   AddChildView(trailing);
 #if defined(OS_WIN)
   set_background(
       views::Background::CreateSolidBackground(
           skia::COLORREFToSkColor(GetSysColor(COLOR_3DFACE))));
 #endif
 }
 
 void SingleSplitView::OnBoundsChanged() {
-  divider_offset_ = CalculateDividerOffset(divider_offset_, previous_bounds_, bounds());
+  divider_offset_ = CalculateDividerOffset(divider_offset_, previous_bounds_,
+                                           bounds());
   View::OnBoundsChanged();
   previous_bounds_ = bounds();
 }
 
 void SingleSplitView::Layout() {
   gfx::Rect leading_bounds;
   gfx::Rect trailing_bounds;
   CalculateChildrenBounds(bounds(), &leading_bounds, &trailing_bounds);
 
-  if (GetChildViewCount() > 0) {
+  if (has_children()) {
     if (GetChildViewAt(0)->IsVisible())
       GetChildViewAt(0)->SetBoundsRect(leading_bounds);
-    if (GetChildViewCount() > 1) {
+    if (child_count() > 1) {
       if (GetChildViewAt(1)->IsVisible())
         GetChildViewAt(1)->SetBoundsRect(trailing_bounds);
     }
   }
 
   SchedulePaint();
 
   // Invoke super's implementation so that the children are layed out.
   View::Layout();
 }
 
 AccessibilityTypes::Role SingleSplitView::GetAccessibleRole() {
   return AccessibilityTypes::ROLE_GROUPING;
 }
 
 gfx::Size SingleSplitView::GetPreferredSize() {
   int width = 0;
   int height = 0;
-  for (int i = 0; i < 2 && i < GetChildViewCount(); ++i) {
+  for (size_t i = 0; i < 2 && i < child_count(); ++i) {
     View* view = GetChildViewAt(i);
     gfx::Size pref = view->GetPreferredSize();
     if (is_horizontal_) {
       width += pref.width();
       height = std::max(height, pref.height());
     } else {
       width = std::max(width, pref.width());
       height += pref.height();
     }
   }
@@ skipping 18 matching lines @@
                               GDK_SB_V_DOUBLE_ARROW);
 #endif
   }
   return NULL;
 }
 
 void SingleSplitView::CalculateChildrenBounds(
     const gfx::Rect& bounds,
     gfx::Rect* leading_bounds,
     gfx::Rect* trailing_bounds) const {
-  bool is_leading_visible =
-      GetChildViewCount() > 0 && GetChildViewAt(0)->IsVisible();
+  bool is_leading_visible = has_children() && GetChildViewAt(0)->IsVisible();
   bool is_trailing_visible =
-      GetChildViewCount() > 1 && GetChildViewAt(1)->IsVisible();
+      child_count() > 1 && GetChildViewAt(1)->IsVisible();
 
   if (!is_leading_visible && !is_trailing_visible) {
     *leading_bounds = gfx::Rect();
     *trailing_bounds = gfx::Rect();
     return;
   }
 
   int divider_at;
 
   if (!is_trailing_visible) {
@@ skipping 26 matching lines @@
 bool SingleSplitView::OnMousePressed(const MouseEvent& event) {
   if (!IsPointInDivider(event.location()))
     return false;
   drag_info_.initial_mouse_offset = GetPrimaryAxisSize(event.x(), event.y());
   drag_info_.initial_divider_offset =
       NormalizeDividerOffset(divider_offset_, bounds());
   return true;
 }
 
 bool SingleSplitView::OnMouseDragged(const MouseEvent& event) {
-  if (GetChildViewCount() < 2)
+  if (child_count() < 2)
     return false;
 
   int delta_offset = GetPrimaryAxisSize(event.x(), event.y()) -
       drag_info_.initial_mouse_offset;
   if (is_horizontal_ && base::i18n::IsRTL())
     delta_offset *= -1;
   // Honor the minimum size when resizing.
   gfx::Size min = GetChildViewAt(0)->GetMinimumSize();
   int new_size = std::max(GetPrimaryAxisSize(min.width(), min.height()),
                           drag_info_.initial_divider_offset + delta_offset);
 
   // And don't let the view get bigger than our width.
   new_size = std::min(GetPrimaryAxisSize() - kDividerSize, new_size);
 
   if (new_size != divider_offset_) {
     set_divider_offset(new_size);
     if (!observer_ || observer_->SplitHandleMoved(this))
       Layout();
   }
   return true;
 }
 
 void SingleSplitView::OnMouseReleased(const MouseEvent& event, bool canceled) {
-  if (GetChildViewCount() < 2)
+  if (child_count() < 2)
     return;
 
   if (canceled && drag_info_.initial_divider_offset != divider_offset_) {
     set_divider_offset(drag_info_.initial_divider_offset);
     if (!observer_ || observer_->SplitHandleMoved(this))
       Layout();
   }
 }
 
 bool SingleSplitView::IsPointInDivider(const gfx::Point& p) {
-  if (GetChildViewCount() < 2)
+  if (child_count() < 2)
     return false;
 
   if (!GetChildViewAt(0)->IsVisible() || !GetChildViewAt(1)->IsVisible())
     return false;
 
   int divider_relative_offset;
   if (is_horizontal_) {
     divider_relative_offset =
         p.x() - GetChildViewAt(base::i18n::IsRTL() ? 1 : 0)->width();
   } else {
@@ skipping 29 matching lines @@
 int SingleSplitView::NormalizeDividerOffset(int divider_offset,
                                             const gfx::Rect& bounds) const {
   int primary_axis_size = GetPrimaryAxisSize(bounds.width(), bounds.height());
   if (divider_offset < 0)
     return (primary_axis_size - kDividerSize) / 2;
   return std::min(divider_offset,
                   std::max(primary_axis_size - kDividerSize, 0));
 }
 
 }  // namespace views