Variety of tweaks to View API.

views/controls/scroll_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/scroll_view.h"
 
 #include "base/logging.h"
 #include "views/controls/scrollbar/native_scroll_bar.h"
 #include "views/widget/root_view.h"
 
@@ skipping 85 matching lines @@
   vert_sb_->SetController(this);
   if (resize_corner_)
     resize_corner_->SetVisible(false);
 }
 
 // Make sure that a single scrollbar is created and visible as needed
 void ScrollView::SetControlVisibility(View* control, bool should_show) {
   if (!control)
     return;
   if (should_show) {
-    if (!control->IsVisible()) {
+    if (!control->visible()) {
       AddChildView(control);
       control->SetVisible(true);
     }
   } else {
     RemoveChildView(control);
     control->SetVisible(false);
   }
 }
 
 void ScrollView::ComputeScrollBarsVisibility(const gfx::Size& vp_size,
@@ skipping 134 matching lines @@
     // This is no op if bounds are the same
     contents_->SetBounds(-x, -y, contents_->width(), contents_->height());
   }
 }
 
 gfx::Rect ScrollView::GetVisibleRect() const {
   if (!contents_)
     return gfx::Rect();
 
   const int x =
-      (horiz_sb_ && horiz_sb_->IsVisible()) ? horiz_sb_->GetPosition() : 0;
+      (horiz_sb_ && horiz_sb_->visible()) ? horiz_sb_->GetPosition() : 0;
   const int y =
-      (vert_sb_ && vert_sb_->IsVisible()) ? vert_sb_->GetPosition() : 0;
+      (vert_sb_ && vert_sb_->visible()) ? vert_sb_->GetPosition() : 0;
   return gfx::Rect(x, y, viewport_->width(), viewport_->height());
 }
 
 void ScrollView::ScrollContentsRegionToBeVisible(const gfx::Rect& rect) {
-  if (!contents_ || ((!horiz_sb_ || !horiz_sb_->IsVisible()) &&
-                     (!vert_sb_ || !vert_sb_->IsVisible()))) {
+  if (!contents_ || ((!horiz_sb_ || !horiz_sb_->visible()) &&
+                     (!vert_sb_ || !vert_sb_->visible()))) {
     return;
   }
 
   // Figure out the maximums for this scroll view.
   const int contents_max_x =
       std::max(viewport_->width(), contents_->width());
   const int contents_max_y =
       std::max(viewport_->height(), contents_->height());
 
   // Make sure x and y are within the bounds of [0,contents_max_*].
@@ skipping 29 matching lines @@
   contents_->SetX(-new_x);
   contents_->SetY(-new_y);
   UpdateScrollBarPositions();
 }
 
 void ScrollView::UpdateScrollBarPositions() {
   if (!contents_) {
     return;
   }
 
-  if (horiz_sb_->IsVisible()) {
+  if (horiz_sb_->visible()) {
     int vw = viewport_->width();
     int cw = contents_->width();
     int origin = contents_->x();
     horiz_sb_->Update(vw, cw, -origin);
   }
-  if (vert_sb_->IsVisible()) {
+  if (vert_sb_->visible()) {
     int vh = viewport_->height();
     int ch = contents_->height();
     int origin = contents_->y();
     vert_sb_->Update(vh, ch, -origin);
   }
 }
 
 // TODO(ACW): We should really use ScrollWindowEx as needed
 void ScrollView::ScrollToPosition(ScrollBar* source, int position) {
   if (!contents_)
     return;
 
-  if (source == horiz_sb_ && horiz_sb_->IsVisible()) {
+  if (source == horiz_sb_ && horiz_sb_->visible()) {
     int vw = viewport_->width();
     int cw = contents_->width();
     int origin = contents_->x();
     if (-origin != position) {
       int max_pos = std::max(0, cw - vw);
       if (position < 0)
         position = 0;
       else if (position > max_pos)
         position = max_pos;
       contents_->SetX(-position);
       contents_->SchedulePaintInRect(contents_->GetVisibleBounds());
     }
-  } else if (source == vert_sb_ && vert_sb_->IsVisible()) {
+  } else if (source == vert_sb_ && vert_sb_->visible()) {
     int vh = viewport_->height();
     int ch = contents_->height();
     int origin = contents_->y();
     if (-origin != position) {
       int max_pos = std::max(0, ch - vh);
       if (position < 0)
         position = 0;
       else if (position > max_pos)
         position = max_pos;
       contents_->SetY(-position);
@@ skipping 18 matching lines @@
   // No view, or the view didn't return a valid amount.
   if (is_page)
     return is_horizontal ? viewport_->width() : viewport_->height();
   return is_horizontal ? viewport_->width() / 5 : viewport_->height() / 5;
 }
 
 bool ScrollView::OnKeyPressed(const KeyEvent& event) {
   bool processed = false;
 
   // Give vertical scrollbar priority
-  if (vert_sb_->IsVisible()) {
+  if (vert_sb_->visible()) {
     processed = vert_sb_->OnKeyPressed(event);
   }
 
-  if (!processed && horiz_sb_->IsVisible()) {
+  if (!processed && horiz_sb_->visible()) {
     processed = horiz_sb_->OnKeyPressed(event);
   }
   return processed;
 }
 
 bool ScrollView::OnMouseWheel(const MouseWheelEvent& e) {
   bool processed = false;
   // Give vertical scrollbar priority
-  if (vert_sb_->IsVisible()) {
+  if (vert_sb_->visible()) {
     processed = vert_sb_->OnMouseWheel(e);
   }
-  if (!processed && horiz_sb_->IsVisible()) {
+  if (!processed && horiz_sb_->visible()) {
     processed = horiz_sb_->OnMouseWheel(e);
   }
   return processed;
 }
 
 std::string ScrollView::GetClassName() const {
   return kViewClassName;
 }
 
 int ScrollView::GetScrollBarWidth() const {
@@ skipping 71 matching lines @@
 
 VariableRowHeightScrollHelper::RowInfo
     FixedRowHeightScrollHelper::GetRowInfo(int y) {
   if (y < top_margin_)
     return RowInfo(0, top_margin_);
   return RowInfo((y - top_margin_) / row_height_ * row_height_ + top_margin_,
                  row_height_);
 }
 
 }  // namespace views