Implement Sebastien's overlay scrollbars for native UI (Views).

ui/views/controls/scrollbar/base_scroll_bar.cc

 // Copyright (c) 2012 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 "ui/views/controls/scrollbar/base_scroll_bar.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 20 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // BaseScrollBar, public:
 
 BaseScrollBar::BaseScrollBar(bool horizontal, BaseScrollBarThumb* thumb)
     : ScrollBar(horizontal),
       thumb_(thumb),
       contents_size_(0),
       contents_scroll_offset_(0),
       viewport_size_(0),
-      thumb_track_state_(CustomButton::STATE_NORMAL),
       last_scroll_amount_(SCROLL_NONE),
       repeater_(base::Bind(&BaseScrollBar::TrackClicked,
                            base::Unretained(this))),
       context_menu_mouse_position_(0) {
   AddChildView(thumb_);
 
   set_context_menu_controller(this);
   thumb_->set_context_menu_controller(this);
 }
 
@@ skipping 53 matching lines @@
   } else if (contents_scroll_offset_ > GetMaxPosition()) {
     contents_scroll_offset_ = GetMaxPosition();
   }
   if (old_offset == contents_scroll_offset_)
     return false;
 
   ScrollContentsToOffset();
   return true;
 }
 
-void BaseScrollBar::OnThumbStateChanged(CustomButton::ButtonState old_state,
-                                        CustomButton::ButtonState new_state) {
-  if (old_state == CustomButton::STATE_PRESSED &&
-      new_state == CustomButton::STATE_NORMAL &&
-      GetThumbTrackState() == CustomButton::STATE_HOVERED) {
-    SetThumbTrackState(CustomButton::STATE_NORMAL);
-  }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // BaseScrollBar, View implementation:
 
 bool BaseScrollBar::OnMousePressed(const ui::MouseEvent& event) {
   if (event.IsOnlyLeftMouseButton())
     ProcessPressEvent(event);
   return true;
 }
 
 void BaseScrollBar::OnMouseReleased(const ui::MouseEvent& event) {
-  SetState(HitTestPoint(event.location()) ?
-           CustomButton::STATE_HOVERED : CustomButton::STATE_NORMAL);
+  repeater_.Stop();
 }
 
 void BaseScrollBar::OnMouseCaptureLost() {
-  SetState(CustomButton::STATE_NORMAL);
-}
-
-void BaseScrollBar::OnMouseEntered(const ui::MouseEvent& event) {
-  SetThumbTrackState(CustomButton::STATE_HOVERED);
-}
-
-void BaseScrollBar::OnMouseExited(const ui::MouseEvent& event) {
-  if (GetThumbTrackState() == CustomButton::STATE_HOVERED)
-    SetState(CustomButton::STATE_NORMAL);
+  repeater_.Stop();
 }
 
 bool BaseScrollBar::OnKeyPressed(const ui::KeyEvent& event) {
   ScrollAmount amount = SCROLL_NONE;
   switch (event.key_code()) {
     case ui::VKEY_UP:
       if (!IsHorizontal())
         amount = SCROLL_PREV_LINE;
       break;
     case ui::VKEY_DOWN:
@@ skipping 50 matching lines @@
     event->SetHandled();
     return;
   }
 
   if (event->type() == ui::ET_GESTURE_LONG_PRESS) {
     // For a long-press, the repeater started in tap-down should continue. So
     // return early.
     return;
   }
 
-  SetState(CustomButton::STATE_NORMAL);
+  repeater_.Stop();
 
   if (event->type() == ui::ET_GESTURE_TAP) {
     // TAP_DOWN would have already scrolled some amount. So scrolling again on
     // TAP is not necessary.
     event->SetHandled();
     return;
   }
 
   if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
       event->type() == ui::ET_GESTURE_SCROLL_END) {
@@ skipping 170 matching lines @@
     contents_scroll_offset = 0;
   if (contents_scroll_offset > content_size)
     contents_scroll_offset = content_size;
   contents_scroll_offset_ = contents_scroll_offset;
 
   // Thumb Height and Thumb Pos.
   // The height of the thumb is the ratio of the Viewport height to the
   // content size multiplied by the height of the thumb track.
   double ratio =
       std::min(1.0, static_cast<double>(viewport_size) / contents_size_);
-  int thumb_size = static_cast<int>(ratio * GetTrackSize());
-  thumb_->SetSize(thumb_size);
+  thumb_->SetLength(static_cast<int>(ratio * GetTrackSize()));
 
   int thumb_position = CalculateThumbPosition(contents_scroll_offset);
   thumb_->SetPosition(thumb_position);
 }
 
 int BaseScrollBar::GetPosition() const {
   return thumb_->GetPosition();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BaseScrollBar, protected:
 
 BaseScrollBarThumb* BaseScrollBar::GetThumb() const {
   return thumb_;
 }
 
-CustomButton::ButtonState BaseScrollBar::GetThumbTrackState() const {
-  return thumb_track_state_;
-}
-
 void BaseScrollBar::ScrollToPosition(int position) {
   controller()->ScrollToPosition(this, position);
 }
 
 int BaseScrollBar::GetScrollIncrement(bool is_page, bool is_positive) {
   return controller()->GetScrollIncrement(this, is_page, is_positive);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BaseScrollBar, private:
 
 int BaseScrollBar::GetThumbSizeForTest() {
   return thumb_->GetSize();
 }
 
 void BaseScrollBar::ProcessPressEvent(const ui::LocatedEvent& event) {
-  SetThumbTrackState(CustomButton::STATE_PRESSED);
   gfx::Rect thumb_bounds = thumb_->bounds();
   if (IsHorizontal()) {
     if (GetMirroredXInView(event.x()) < thumb_bounds.x()) {
       last_scroll_amount_ = SCROLL_PREV_PAGE;
     } else if (GetMirroredXInView(event.x()) > thumb_bounds.right()) {
       last_scroll_amount_ = SCROLL_NEXT_PAGE;
     }
   } else {
     if (event.y() < thumb_bounds.y()) {
       last_scroll_amount_ = SCROLL_PREV_PAGE;
     } else if (event.y() > thumb_bounds.bottom()) {
       last_scroll_amount_ = SCROLL_NEXT_PAGE;
     }
   }
   TrackClicked();
   repeater_.Start();
 }
 
-void BaseScrollBar::SetState(CustomButton::ButtonState state) {
-  SetThumbTrackState(state);
-  repeater_.Stop();
-}
-
 void BaseScrollBar::TrackClicked() {
   if (last_scroll_amount_ != SCROLL_NONE)
     ScrollByAmount(last_scroll_amount_);
 }
 
 void BaseScrollBar::ScrollContentsToOffset() {
   ScrollToPosition(contents_scroll_offset_);
   thumb_->SetPosition(CalculateThumbPosition(contents_scroll_offset_));
 }
 
@@ skipping 18 matching lines @@
   int thumb_size = thumb_->GetSize();
   int track_size = GetTrackSize();
   if (track_size == thumb_size)
     return 0;
   if (scroll_to_middle)
     thumb_position = thumb_position - (thumb_size / 2);
   return (thumb_position * (contents_size_ - viewport_size_)) /
          (track_size - thumb_size);
 }
 
-void BaseScrollBar::SetThumbTrackState(CustomButton::ButtonState state) {
-  thumb_track_state_ = state;
-  SchedulePaint();
-}
-
 }  // namespace views