Change focus indicator for TableView and TreeView.

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"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/focus_ring.h"
 #include "ui/views/style/platform_style.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 
 const char ScrollView::kViewClassName[] = "ScrollView";
 
 namespace {
 
 const base::Feature kToolkitViewsScrollWithLayers {
   "ToolkitViewsScrollWithLayers",
 #if defined(OS_MACOSX)
       base::FEATURE_ENABLED_BY_DEFAULT
 #else
       base::FEATURE_DISABLED_BY_DEFAULT
 #endif
 };
 
-// Subclass of ScrollView that resets the border when the theme changes.
-class ScrollViewWithBorder : public views::ScrollView {
- public:
-  ScrollViewWithBorder() {}
-
-  // View overrides;
-  void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
-    SetBorder(CreateSolidBorder(
-        1,
-        theme->GetSystemColor(ui::NativeTheme::kColorId_UnfocusedBorderColor)));
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScrollViewWithBorder);
-};
-
-class ScrollCornerView : public views::View {
+class ScrollCornerView : public View {
  public:
   ScrollCornerView() {}
 
   void OnPaint(gfx::Canvas* canvas) override {
     ui::NativeTheme::ExtraParams ignored;
     GetNativeTheme()->Paint(canvas->sk_canvas(),
                             ui::NativeTheme::kScrollbarCorner,
                             ui::NativeTheme::kNormal,
                             GetLocalBounds(),
                             ignored);
@@ skipping 128 matching lines @@
 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_;
 }
 
 // static
 ScrollView* ScrollView::CreateScrollViewWithBorder() {
-  return new ScrollViewWithBorder();
+  auto scroll_view = new ScrollView();
+  scroll_view->AddBorder();
+  return scroll_view;
+}
+
+// static
+ScrollView* ScrollView::GetScrollViewForContents(View* contents) {
+  View* grandparent =
+      contents->parent() ? contents->parent()->parent() : nullptr;
+  if (!grandparent || grandparent->GetClassName() != ScrollView::kViewClassName)
+    return nullptr;
+
+  auto scroll_view = static_cast<ScrollView*>(grandparent);
+  DCHECK_EQ(contents, scroll_view->contents());
+  return scroll_view;
 }
 
 void ScrollView::SetContents(View* a_view) {
   // Protect against clients passing a contents view that has its own Layer.
   DCHECK(!a_view->layer());
   if (ScrollsWithLayers()) {
     if (!a_view->background() && background_color_ != SK_ColorTRANSPARENT) {
       a_view->set_background(
           Background::CreateSolidBackground(background_color_));
     }
@@ skipping 52 matching lines @@
 }
 
 void ScrollView::SetVerticalScrollBar(ScrollBar* vert_sb) {
   DCHECK(vert_sb);
   vert_sb->SetVisible(vert_sb_->visible());
   delete vert_sb_;
   vert_sb->set_controller(this);
   vert_sb_ = vert_sb;
 }
 
-void ScrollView::SetHasFocusRing(bool has_focus_ring) {
-  if (has_focus_ring == (focus_ring_ != nullptr))
+void ScrollView::SetHasFocusIndicator(bool has_focus_indicator) {
+  if (has_focus_indicator == draw_focus_indicator_)
     return;
-  if (has_focus_ring) {
-    focus_ring_ = FocusRing::Install(this);
+  draw_focus_indicator_ = has_focus_indicator;
+
+  if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
+    DCHECK_EQ(draw_focus_indicator_, !focus_ring_);
+    if (has_focus_indicator) {
+      focus_ring_ = FocusRing::Install(this);
+    } else {
+      FocusRing::Uninstall(this);
+      focus_ring_ = nullptr;
+    }
   } else {
-    FocusRing::Uninstall(this);
-    focus_ring_ = nullptr;
+    UpdateBorder();
   }
   SchedulePaint();
 }
 
 gfx::Size ScrollView::GetPreferredSize() const {
   if (!is_bounded())
     return View::GetPreferredSize();
 
   gfx::Size size = contents_->GetPreferredSize();
   size.SetToMax(gfx::Size(size.width(), min_height_));
@@ skipping 220 matching lines @@
   if (!event->handled() && horiz_sb_->visible()) {
     if (horiz_sb_->bounds().Contains(event->location()) || scroll_event)
       horiz_sb_->OnGestureEvent(event);
   }
 }
 
 const char* ScrollView::GetClassName() const {
   return kViewClassName;
 }
 
+void ScrollView::OnNativeThemeChanged(const ui::NativeTheme* theme) {
+  UpdateBorder();
+}
+
 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 199 matching lines @@
   if (!header_)
     return;
 
   int x_offset = CurrentOffset().x();
   if (header_->x() != -x_offset) {
     header_->SetX(-x_offset);
     header_->SchedulePaintInRect(header_->GetVisibleBounds());
   }
 }
 
+void ScrollView::AddBorder() {
+  draw_border_ = true;
+  UpdateBorder();
+}
+
+void ScrollView::UpdateBorder() {
+  if (!draw_border_ || !GetWidget())
+    return;
+
+  SetBorder(CreateSolidBorder(
+      1,
+      GetNativeTheme()->GetSystemColor(
+          draw_focus_indicator_
+              ? ui::NativeTheme::kColorId_FocusedBorderColor
+              : ui::NativeTheme::kColorId_UnfocusedBorderColor)));
+}
+
 // 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