Ensure that the focus ring in the bookmarks bar does not paint outside the parent view.

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/base/material_design/material_design_controller.h"
@@ skipping 43 matching lines @@
 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;
 }
 
 // Make sure the content is not scrolled out of bounds
-void ConstrainScrollToBounds(View* viewport, View* view) {
+void ConstrainScrollToBounds(View* viewport,
+                             View* view,
+                             bool scroll_with_layers_enabled) {
   if (!view)
     return;
 
   // Note that even when ScrollView::ScrollsWithLayers() is true, the header row
   // scrolls by repainting.
-  const bool scrolls_with_layers = viewport->layer() != nullptr;
+  const bool scrolls_with_layers =
+      scroll_with_layers_enabled && viewport->layer() != nullptr;
   if (scrolls_with_layers) {
     DCHECK(view->layer());
     DCHECK_EQ(0, view->x());
     DCHECK_EQ(0, view->y());
   }
   gfx::ScrollOffset offset = scrolls_with_layers
                                  ? view->layer()->CurrentScrollOffset()
                                  : gfx::ScrollOffset(-view->x(), -view->y());
 
   int x = CheckScrollBounds(viewport->width(), view->width(), offset.x());
@@ skipping 64 matching lines @@
     : contents_(NULL),
       contents_viewport_(new Viewport()),
       header_(NULL),
       header_viewport_(new Viewport()),
       horiz_sb_(PlatformStyle::CreateScrollBar(true).release()),
       vert_sb_(PlatformStyle::CreateScrollBar(false).release()),
       corner_view_(new ScrollCornerView()),
       min_height_(-1),
       max_height_(-1),
       background_color_(SK_ColorTRANSPARENT),
-      hide_horizontal_scrollbar_(false) {
+      hide_horizontal_scrollbar_(false),
+      scroll_with_layers_enabled_(
+          base::FeatureList::IsEnabled(kToolkitViewsScrollWithLayers)) {
   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);
   corner_view_->SetVisible(false);
 
-  if (!base::FeatureList::IsEnabled(kToolkitViewsScrollWithLayers))
+  if (!scroll_with_layers_enabled_)
     return;
+
   EnableViewPortLayer();
 }
 
 ScrollView::~ScrollView() {
   // The scrollbars may not have been added, delete them to ensure they get
   // deleted.
   delete horiz_sb_;
   delete vert_sb_;
   delete corner_view_;
 }
@@ skipping 262 matching lines @@
     gfx::Size container_size = contents_ ? contents_->size() : gfx::Size();
     container_size.SetToMax(viewport_bounds.size());
     contents_->SetBoundsRect(gfx::Rect(container_size));
   }
 
   header_viewport_->SetBounds(contents_x, contents_y,
                               viewport_bounds.width(), header_height);
   if (header_)
     header_->Layout();
 
-  ConstrainScrollToBounds(header_viewport_, header_);
-  ConstrainScrollToBounds(contents_viewport_, contents_);
+  ConstrainScrollToBounds(header_viewport_, header_,
+                          scroll_with_layers_enabled_);
+  ConstrainScrollToBounds(contents_viewport_, contents_,
+                          scroll_with_layers_enabled_);
   SchedulePaint();
   UpdateScrollBarPositions();
 }
 
 bool ScrollView::OnKeyPressed(const ui::KeyEvent& event) {
   bool processed = false;
 
   // Give vertical scrollbar priority
   if (vert_sb_->visible())
     processed = vert_sb_->OnKeyPressed(event);
@@ skipping 55 matching lines @@
 }
 
 const char* ScrollView::GetClassName() const {
   return kViewClassName;
 }
 
 void ScrollView::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   UpdateBorder();
 }
 
+void ScrollView::ViewHierarchyChanged(
+    const ViewHierarchyChangedDetails& details) {
+  if (details.is_add && !viewport_layer_enabled_ && Contains(details.parent))
+    EnableLayeringRecursivelyForChild(details.child);
+}
+
+void ScrollView::OnChildLayerChanged(View* child) {
+  EnableViewPortLayer();
+}
+
 void ScrollView::ScrollToPosition(ScrollBar* source, int position) {
   if (!contents_)
     return;
 
   gfx::ScrollOffset offset = CurrentOffset();
   if (source == horiz_sb_ && horiz_sb_->visible()) {
     position = AdjustPosition(offset.x(), position, contents_->width(),
                               contents_viewport_->width());
     if (offset.x() == position)
       return;
@@ skipping 170 matching lines @@
     // and commits a frame, which isn't true in some tests.
     // See http://crbug.com/637521.
     OnLayerScrolled(offset);
   } else {
     contents_->SetPosition(gfx::Point(-offset.x(), -offset.y()));
     ScrollHeader();
   }
 }
 
 bool ScrollView::ScrollsWithLayers() const {
+  if (!scroll_with_layers_enabled_)
+    return false;
   // Just check for the presence of a layer since it's cheaper than querying the
   // Feature flag each time.
   return contents_viewport_->layer() != nullptr;
 }
 
 void ScrollView::EnableViewPortLayer() {
+  if (viewport_layer_enabled_)
+    return;
+
+  viewport_layer_enabled_ = true;
   background_color_ = SK_ColorWHITE;
   contents_viewport_->set_background(
       Background::CreateSolidBackground(background_color_));
   contents_viewport_->SetPaintToLayer();
   contents_viewport_->layer()->SetMasksToBounds(true);
 }
 
 void ScrollView::OnLayerScrolled(const gfx::ScrollOffset&) {
   UpdateScrollBarPositions();
   ScrollHeader();
@@ skipping 20 matching lines @@
     return;
 
   SetBorder(CreateSolidBorder(
       1,
       GetNativeTheme()->GetSystemColor(
           draw_focus_indicator_
               ? ui::NativeTheme::kColorId_FocusedBorderColor
               : ui::NativeTheme::kColorId_UnfocusedBorderColor)));
 }
 
+bool ScrollView::EnableLayeringRecursivelyForChild(View* view) {
+  if (viewport_layer_enabled_ || scroll_with_layers_enabled_)
+    return true;
+
+  if (view->layer()) {
+    EnableViewPortLayer();
+    return true;
+  }
+
+  for (int i = 0; i < view->child_count(); ++i) {
+    if (EnableLayeringRecursivelyForChild(view->child_at(i)))
+      return true;
+  }
+  return false;
+}
+
 // VariableRowHeightScrollHelper ----------------------------------------------
 
 VariableRowHeightScrollHelper::VariableRowHeightScrollHelper(
     Controller* controller) : controller_(controller) {
 }
 
 VariableRowHeightScrollHelper::~VariableRowHeightScrollHelper() {
 }
 
 int VariableRowHeightScrollHelper::GetPageScrollIncrement(
@@ skipping 54 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