Revert of 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
 };
 
-class ScrollCornerView : public View {
+// 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 {
  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() {
-  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;
+  return new ScrollViewWithBorder();
 }
 
 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::SetHasFocusIndicator(bool has_focus_indicator) {
-  if (has_focus_indicator == draw_focus_indicator_)
+void ScrollView::SetHasFocusRing(bool has_focus_ring) {
+  if (has_focus_ring == (focus_ring_ != nullptr))
     return;
-  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;
-    }
+  if (has_focus_ring) {
+    focus_ring_ = FocusRing::Install(this);
   } else {
-    UpdateBorder();
+    FocusRing::Uninstall(this);
+    focus_ring_ = nullptr;
   }
   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