Disambiguate OnMouseCaptureLost from OnMouseReleased, etc.

views/controls/scrollbar/bitmap_scroll_bar.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/controls/scrollbar/bitmap_scroll_bar.h"
 
 #if defined(OS_LINUX)
 #include "views/screen.h"
 #endif
 
@@ skipping 36 matching lines @@
  public:
   AutorepeatButton(ButtonListener* listener)
       : ImageButton(listener),
         ALLOW_THIS_IN_INITIALIZER_LIST(repeater_(
             NewCallback<AutorepeatButton>(this,
                                           &AutorepeatButton::NotifyClick))) {
   }
   virtual ~AutorepeatButton() {}
 
  protected:
-  virtual bool OnMousePressed(const MouseEvent& event) {
+  virtual bool OnMousePressed(const MouseEvent& event) OVERRIDE {
     Button::NotifyClick(event);
     repeater_.Start();
     return true;
   }
 
-  virtual void OnMouseReleased(const MouseEvent& event, bool canceled) {
+  virtual void OnMouseReleased(const MouseEvent& event) OVERRIDE {
+    OnMouseCaptureLost();
+  }
+
+  virtual void OnMouseCaptureLost() OVERRIDE {
     repeater_.Stop();
-    View::OnMouseReleased(event, canceled);
   }
 
  private:
   void NotifyClick() {
 #if defined(OS_WIN)
     DWORD pos = GetMessagePos();
     POINTS points = MAKEPOINTS(pos);
     gfx::Point cursor_point(points.x, points.y);
 #elif defined(OS_LINUX)
     gfx::Point cursor_point = Screen::GetCursorScreenPoint();
@@ skipping 66 matching lines @@
 
   // Gets the position of the thumb on the x or y axis.
   int GetPosition() const {
     gfx::Rect track_bounds = scroll_bar_->GetTrackBounds();
     if (scroll_bar_->IsHorizontal())
       return x() - track_bounds.x();
     return y() - track_bounds.y();
   }
 
   // View overrides:
-  virtual gfx::Size GetPreferredSize() {
+  virtual gfx::Size GetPreferredSize() OVERRIDE {
     return gfx::Size(background_bitmap()->width(),
                      start_cap_bitmap()->height() +
                          end_cap_bitmap()->height() +
                          grippy_bitmap()->height());
   }
 
  protected:
   // View overrides:
-  virtual void Paint(gfx::Canvas* canvas) {
+  virtual void Paint(gfx::Canvas* canvas) OVERRIDE {
     canvas->DrawBitmapInt(*start_cap_bitmap(), 0, 0);
     int top_cap_height = start_cap_bitmap()->height();
     int bottom_cap_height = end_cap_bitmap()->height();
     int thumb_body_height = height() - top_cap_height - bottom_cap_height;
     canvas->TileImageInt(*background_bitmap(), 0, top_cap_height,
                          background_bitmap()->width(), thumb_body_height);
     canvas->DrawBitmapInt(*end_cap_bitmap(), 0,
                           height() - bottom_cap_height);
 
     // Paint the grippy over the track.
     int grippy_x = (width() - grippy_bitmap()->width()) / 2;
     int grippy_y = (thumb_body_height - grippy_bitmap()->height()) / 2;
     canvas->DrawBitmapInt(*grippy_bitmap(), grippy_x, grippy_y);
   }
 
-  virtual void OnMouseEntered(const MouseEvent& event) {
+  virtual void OnMouseEntered(const MouseEvent& event) OVERRIDE {
     SetState(CustomButton::BS_HOT);
   }
 
-  virtual void OnMouseExited(const MouseEvent& event) {
+  virtual void OnMouseExited(const MouseEvent& event) OVERRIDE {
     SetState(CustomButton::BS_NORMAL);
   }
 
-  virtual bool OnMousePressed(const MouseEvent& event) {
+  virtual bool OnMousePressed(const MouseEvent& event) OVERRIDE {
     mouse_offset_ = scroll_bar_->IsHorizontal() ? event.x() : event.y();
     drag_start_position_ = GetPosition();
     SetState(CustomButton::BS_PUSHED);
     return true;
   }
 
-  virtual bool OnMouseDragged(const MouseEvent& event) {
+  virtual bool OnMouseDragged(const MouseEvent& event) OVERRIDE {
     // If the user moves the mouse more than |kScrollThumbDragOutSnap| outside
     // the bounds of the thumb, the scrollbar will snap the scroll back to the
     // point it was at before the drag began.
     if (scroll_bar_->IsHorizontal()) {
       if ((event.y() < y() - kScrollThumbDragOutSnap) ||
           (event.y() > (y() + height() + kScrollThumbDragOutSnap))) {
         scroll_bar_->ScrollToThumbPosition(drag_start_position_, false);
         return true;
       }
     } else {
       if ((event.x() < x() - kScrollThumbDragOutSnap) ||
           (event.x() > (x() + width() + kScrollThumbDragOutSnap))) {
         scroll_bar_->ScrollToThumbPosition(drag_start_position_, false);
         return true;
       }
     }
     if (scroll_bar_->IsHorizontal()) {
       int thumb_x = event.x() - mouse_offset_;
       scroll_bar_->ScrollToThumbPosition(x() + thumb_x, false);
     } else {
       int thumb_y = event.y() - mouse_offset_;
       scroll_bar_->ScrollToThumbPosition(y() + thumb_y, false);
     }
     return true;
   }
 
-  virtual void OnMouseReleased(const MouseEvent& event,
-                               bool canceled) {
+  virtual void OnMouseReleased(const MouseEvent& event) OVERRIDE {
+    OnMouseCaptureLost();
+  }
+
+  virtual void OnMouseCaptureLost() OVERRIDE {
     SetState(CustomButton::BS_HOT);
-    View::OnMouseReleased(event, canceled);
   }
 
  private:
   // Returns the bitmap rendered at the start of the thumb.
   SkBitmap* start_cap_bitmap() const {
     return scroll_bar_->images_[BitmapScrollBar::THUMB_START_CAP][state_];
   }
 
   // Returns the bitmap rendered at the end of the thumb.
   SkBitmap* end_cap_bitmap() const {
@@ skipping 231 matching lines @@
       } else if (event.y() > thumb_bounds.bottom()) {
         last_scroll_amount_ = SCROLL_NEXT_PAGE;
       }
     }
     TrackClicked();
     repeater_.Start();
   }
   return true;
 }
 
-void BitmapScrollBar::OnMouseReleased(const MouseEvent& event, bool canceled) {
+void BitmapScrollBar::OnMouseReleased(const MouseEvent& event) {
+  OnMouseCaptureLost();
+}
+
+void BitmapScrollBar::OnMouseCaptureLost() {
   SetThumbTrackState(CustomButton::BS_NORMAL);
   repeater_.Stop();
-  View::OnMouseReleased(event, canceled);
 }
 
 bool BitmapScrollBar::OnKeyPressed(const 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 231 matching lines @@
     thumb_position = thumb_position - (thumb_->GetSize() / 2);
   return (thumb_position * contents_size_) / GetTrackSize();
 }
 
 void BitmapScrollBar::SetThumbTrackState(CustomButton::ButtonState state) {
   thumb_track_state_ = state;
   SchedulePaint();
 }
 
 }  // namespace views