Improving the appearance of overlay 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/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "ui/events/event.h"
@@ skipping 225 matching lines @@
   gfx::ScrollOffset offset = CurrentOffset();
   return gfx::Rect(offset.x(), offset.y(), contents_viewport_->width(),
                    contents_viewport_->height());
 }
 
 void ScrollView::ClipHeightTo(int min_height, int max_height) {
   min_height_ = min_height;
   max_height_ = max_height;
 }
 
-int ScrollView::GetScrollBarWidth() const {
-  return vert_sb_ ? vert_sb_->GetLayoutSize() : 0;
+int ScrollView::GetScrollBarLayoutWidth() const {
+  return vert_sb_ && !vert_sb_->OverlapsContent() ? vert_sb_->GetThickness()
+                                                  : 0;
 }
 
-int ScrollView::GetScrollBarHeight() const {
-  return horiz_sb_ ? horiz_sb_->GetLayoutSize() : 0;
+int ScrollView::GetScrollBarLayoutHeight() const {
+  return horiz_sb_ && !horiz_sb_->OverlapsContent() ? horiz_sb_->GetThickness()
+                                                    : 0;
 }
 
 void ScrollView::SetHorizontalScrollBar(ScrollBar* horiz_sb) {
   DCHECK(horiz_sb);
   horiz_sb->SetVisible(horiz_sb_->visible());
   delete horiz_sb_;
   horiz_sb->set_controller(this);
   horiz_sb_ = horiz_sb;
 }
 
@@ skipping 33 matching lines @@
   if (!is_bounded())
     return View::GetHeightForWidth(width);
 
   gfx::Insets insets = GetInsets();
   width = std::max(0, width - insets.width());
   int height = contents_->GetHeightForWidth(width) + insets.height();
   return std::min(std::max(height, min_height_), max_height_);
 }
 
 void ScrollView::Layout() {
+#if defined(OS_MACOSX)
+  // On Mac, scrollbars may update their style one at a time, so they may
+  // temporarily be of different types. Refuse to lay out at this point.
+  if (horiz_sb_->OverlapsContent() != vert_sb_->OverlapsContent())

[Evan Stade, 2016/12/13 00:51:52]

Sadrul, do you mind this change that I had to make to satisfy Mac? I don't think
there's an easy way around it. See [1] which triggers layout after only one of
the bars (vertical or horizontal) has been updated to a different style.

[1]
https://cs.chromium.org/chromium/src/ui/views/controls/scrollbar/cocoa_scroll...

+    return;
+#endif
+  DCHECK_EQ(horiz_sb_->OverlapsContent(), vert_sb_->OverlapsContent());
+
   if (focus_ring_)
     focus_ring_->Layout();
 
   gfx::Rect available_rect = GetContentsBounds();
   if (is_bounded()) {
     int content_width = available_rect.width();
     int content_height = contents_->GetHeightForWidth(content_width);
     if (content_height > height()) {
-      content_width = std::max(content_width - GetScrollBarWidth(), 0);
+      content_width = std::max(content_width - GetScrollBarLayoutWidth(), 0);
       content_height = contents_->GetHeightForWidth(content_width);
     }
     contents_->SetSize(gfx::Size(content_width, content_height));
   }
 
   // Most views will want to auto-fit the available space. Most of them want to
   // use all available width (without overflowing) and only overflow in
   // height. Examples are HistoryView, MostVisitedView, DownloadTabView, etc.
   // Other views want to fit in both ways. An example is PrintView. To make both
   // happy, assume a vertical scrollbar but no horizontal scrollbar. To override
@@ skipping 11 matching lines @@
   const int header_height =
       std::min(viewport_bounds.height(),
                header_ ? header_->GetPreferredSize().height() : 0);
   viewport_bounds.set_height(
       std::max(0, viewport_bounds.height() - header_height));
   viewport_bounds.set_y(viewport_bounds.y() + header_height);
   // viewport_size is the total client space available.
   gfx::Size viewport_size = viewport_bounds.size();
   // Assumes a vertical scrollbar since most of the current views are designed
   // for this.
-  int horiz_sb_height = GetScrollBarHeight();
-  int vert_sb_width = GetScrollBarWidth();
-  viewport_bounds.set_width(viewport_bounds.width() - vert_sb_width);
+  const int horiz_sb_layout_height = GetScrollBarLayoutHeight();
+  const int vert_sb_layout_width = GetScrollBarLayoutWidth();
+  viewport_bounds.set_width(viewport_bounds.width() - vert_sb_layout_width);
   // Update the bounds right now so the inner views can fit in it.
   contents_viewport_->SetBoundsRect(viewport_bounds);
 
   // Give |contents_| a chance to update its bounds if it depends on the
   // viewport.
   if (contents_)
     contents_->Layout();
 
   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 corner_view_required = horiz_sb_required && vert_sb_required;
+  // Overlay scrollbars don't need a corner view.
+  bool corner_view_required =
+      horiz_sb_required && vert_sb_required && !vert_sb_->OverlapsContent();
   // Take action.
   SetControlVisibility(horiz_sb_, horiz_sb_required);
   SetControlVisibility(vert_sb_, vert_sb_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));
+        std::max(0, viewport_bounds.height() - horiz_sb_layout_height));
     should_layout_contents = true;
   }
   // Default.
   if (!vert_sb_required) {
-    viewport_bounds.set_width(viewport_bounds.width() + vert_sb_width);
+    viewport_bounds.set_width(viewport_bounds.width() + vert_sb_layout_width);
     should_layout_contents = true;
   }
 
-  int height_offset = horiz_sb_required ?
-      horiz_sb_->GetContentOverlapSize() : 0;
-  int width_offset = vert_sb_required ?
-      vert_sb_->GetContentOverlapSize() : 0;
+  if (horiz_sb_required) {
+    gfx::Rect horiz_sb_bounds(contents_x, viewport_bounds.bottom(),
+                              viewport_bounds.right() - contents_x,
+                              horiz_sb_layout_height);
+    if (horiz_sb_->OverlapsContent()) {
+      horiz_sb_bounds.Inset(
+          gfx::Insets(-horiz_sb_->GetThickness(), 0, 0,
+                      vert_sb_required ? vert_sb_->GetThickness() : 0));
+    }
 
-  if (horiz_sb_required) {
-    horiz_sb_->SetBounds(contents_x,
-                         viewport_bounds.bottom() - height_offset,
-                         viewport_bounds.right() - contents_x - width_offset,
-                         horiz_sb_height + height_offset);
+    horiz_sb_->SetBoundsRect(horiz_sb_bounds);
   }
   if (vert_sb_required) {
-    int width_offset = vert_sb_->GetContentOverlapSize();
-    vert_sb_->SetBounds(viewport_bounds.right() - width_offset,
-                        contents_y,
-                        vert_sb_width + width_offset,
-                        viewport_bounds.bottom() - contents_y - height_offset);
+    gfx::Rect vert_sb_bounds(viewport_bounds.right(), contents_y,
+                             vert_sb_layout_width,
+                             viewport_bounds.bottom() - contents_y);
+    if (vert_sb_->OverlapsContent()) {
+      // In the overlay scrollbar case, the scrollbar only covers the viewport
+      // (and not the header).
+      vert_sb_bounds.Inset(
+          gfx::Insets(header_height, -vert_sb_->GetThickness(),
+                      horiz_sb_required ? horiz_sb_->GetThickness() : 0, 0));
+    }
+
+    vert_sb_->SetBoundsRect(vert_sb_bounds);
   }
   if (corner_view_required) {
     // Show the resize corner.
     corner_view_->SetBounds(vert_sb_->bounds().x(), horiz_sb_->bounds().y(),
-                            vert_sb_width, horiz_sb_height);
+                            vert_sb_layout_width, horiz_sb_layout_height);
   }
 
   // Update to the real client size with the visible scrollbars.
   contents_viewport_->SetBoundsRect(viewport_bounds);
   if (should_layout_contents && contents_)
     contents_->Layout();
 
   // Even when |contents_| needs to scroll, it can still be narrower or wider
   // the viewport. So ensure the scrolling layer can fill the viewport, so that
   // events will correctly hit it, and overscroll looks correct.
@@ skipping 196 matching lines @@
     *vert_is_shown = content_size.height() > vp_size.height();
     return;
   }
 
   // Try to fit both ways first, then try vertical bar only, then horizontal
   // bar only, then defaults to both shown.
   if (content_size.width() <= vp_size.width() &&
       content_size.height() <= vp_size.height()) {
     *horiz_is_shown = false;
     *vert_is_shown = false;
-  } else if (content_size.width() <= vp_size.width() - GetScrollBarWidth()) {
+  } else if (content_size.width() <=
+             vp_size.width() - GetScrollBarLayoutWidth()) {
     *horiz_is_shown = false;
     *vert_is_shown = true;
-  } else if (content_size.height() <= vp_size.height() - GetScrollBarHeight()) {
+  } else if (content_size.height() <=
+             vp_size.height() - GetScrollBarLayoutHeight()) {
     *horiz_is_shown = true;
     *vert_is_shown = false;
   } else {
     *horiz_is_shown = true;
     *vert_is_shown = true;
   }
 }
 
 // Make sure that a single scrollbar is created and visible as needed
 void ScrollView::SetControlVisibility(View* control, bool should_show) {
@@ skipping 145 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