Allow the native theme to paint the corner between scrollbars

ui/views/controls/scroll_view.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/scroll_view.h"
 
 #include "base/logging.h"
 #include "ui/events/event.h"
+#include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/scrollbar/native_scroll_bar.h"
 #include "ui/views/widget/root_view.h"
 
 namespace views {
 
 const char ScrollView::kViewClassName[] = "ScrollView";
 
 namespace {
 
 // Subclass of ScrollView that resets the border when the theme changes.
 class ScrollViewWithBorder : public views::ScrollView {
  public:
   ScrollViewWithBorder() {}
 
   // View overrides;
   virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) OVERRIDE {
     SetBorder(Border::CreateSolidBorder(
         1,
         theme->GetSystemColor(ui::NativeTheme::kColorId_UnfocusedBorderColor)));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScrollViewWithBorder);
 };
 
+class ScrollCornerView : public views::View {
+ public:
+  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
+    ui::NativeTheme::ExtraParams ignored;
+    GetNativeTheme()->Paint(canvas->sk_canvas(),
+                            ui::NativeTheme::kScrollbarCorner,
+                            ui::NativeTheme::kNormal,
+                            GetLocalBounds(),
+                            ignored);
+  }
+};

[sky, 2014/08/13 03:33:11]

private: DISALLOW...

[Andre, 2014/08/13 17:53:35]

Done.

+
 // Returns the position for the view so that it isn't scrolled off the visible
 // region.
 int CheckScrollBounds(int viewport_size, int content_size, int current_pos) {
   int max = std::max(content_size - viewport_size, 0);
   if (current_pos < 0)
     return 0;
   if (current_pos > max)
     return max;
   return current_pos;
 }
@@ skipping 56 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Viewport);
 };
 
 ScrollView::ScrollView()
     : contents_(NULL),
       contents_viewport_(new Viewport()),
       header_(NULL),
       header_viewport_(new Viewport()),
       horiz_sb_(new NativeScrollBar(true)),
       vert_sb_(new NativeScrollBar(false)),
-      resize_corner_(NULL),
+      corner_view_(new ScrollCornerView()),
       min_height_(-1),
       max_height_(-1),
       hide_horizontal_scrollbar_(false) {
   set_notify_enter_exit_on_child(true);
 
   AddChildView(contents_viewport_);
   AddChildView(header_viewport_);
 
   // Don't add the scrollbars as children until we discover we need them
   // (ShowOrHideScrollBar).
   horiz_sb_->SetVisible(false);
   horiz_sb_->set_controller(this);
   vert_sb_->SetVisible(false);
   vert_sb_->set_controller(this);
-  if (resize_corner_)
-    resize_corner_->SetVisible(false);
+  corner_view_->SetVisible(false);
 }
 
 ScrollView::~ScrollView() {
   // The scrollbars may not have been added, delete them to ensure they get
   // deleted.
   delete horiz_sb_;
   delete vert_sb_;
-
-  if (resize_corner_ && !resize_corner_->parent())
-    delete resize_corner_;
+  delete corner_view_;
 }
 
 // static
 ScrollView* ScrollView::CreateScrollViewWithBorder() {
   return new ScrollViewWithBorder();
 }
 
 void ScrollView::SetContents(View* a_view) {
   SetHeaderOrContents(contents_viewport_, a_view, &contents_);
 }
@@ skipping 112 matching lines @@
   bool should_layout_contents = false;
   bool horiz_sb_required = false;
   bool vert_sb_required = false;
   if (contents_) {
     gfx::Size content_size = contents_->size();
     ComputeScrollBarsVisibility(viewport_size,
                                 content_size,
                                 &horiz_sb_required,
                                 &vert_sb_required);
   }
-  bool resize_corner_required = resize_corner_ && horiz_sb_required &&
-                                vert_sb_required;
+  bool corner_view_required = horiz_sb_required && vert_sb_required;
   // Take action.
   SetControlVisibility(horiz_sb_, horiz_sb_required);
   SetControlVisibility(vert_sb_, vert_sb_required);
-  SetControlVisibility(resize_corner_, resize_corner_required);
+  SetControlVisibility(corner_view_, corner_view_required);
 
   // Non-default.
   if (horiz_sb_required) {
     viewport_bounds.set_height(
         std::max(0, viewport_bounds.height() - horiz_sb_height));
     should_layout_contents = true;
   }
   // Default.
   if (!vert_sb_required) {
     viewport_bounds.set_width(viewport_bounds.width() + vert_sb_width);
     should_layout_contents = true;
   }
 
   if (horiz_sb_required) {
     int height_offset = horiz_sb_->GetContentOverlapSize();
     horiz_sb_->SetBounds(0,
                          viewport_bounds.bottom() - height_offset,
                          viewport_bounds.right(),
                          horiz_sb_height + height_offset);
   }
   if (vert_sb_required) {
     int width_offset = vert_sb_->GetContentOverlapSize();
     vert_sb_->SetBounds(viewport_bounds.right() - width_offset,
                         0,
                         vert_sb_width + width_offset,
                         viewport_bounds.bottom());
   }
-  if (resize_corner_required) {
+  if (corner_view_required) {
     // Show the resize corner.
-    resize_corner_->SetBounds(viewport_bounds.right(),
-                              viewport_bounds.bottom(),
-                              vert_sb_width,
-                              horiz_sb_height);
+    corner_view_->SetBounds(viewport_bounds.right(),
+                            viewport_bounds.bottom(),
+                            vert_sb_width,
+                            horiz_sb_height);
   }
 
   // Update to the real client size with the visible scrollbars.
   contents_viewport_->SetBoundsRect(viewport_bounds);
   if (should_layout_contents && contents_)
     contents_->Layout();
 
   header_viewport_->SetBounds(contents_x, contents_y,
                               viewport_bounds.width(), header_height);
   if (header_)
@@ skipping 301 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