Hardcode ripple color/opacity for Harmony.

ui/views/animation/ink_drop_host_view.cc

 // Copyright 2016 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/animation/ink_drop_host_view.h"
 
 #include "base/memory/ptr_util.h"
+#include "ui/base/material_design/material_design_controller.h"
 #include "ui/events/event.h"
 #include "ui/events/scoped_target_handler.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/size_conversions.h"
+#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
 #include "ui/views/animation/ink_drop.h"
 #include "ui/views/animation/ink_drop_highlight.h"
 #include "ui/views/animation/ink_drop_impl.h"
 #include "ui/views/animation/ink_drop_mask.h"
 #include "ui/views/animation/ink_drop_stub.h"
 #include "ui/views/animation/square_ink_drop_ripple.h"
 #include "ui/views/style/platform_style.h"
 
 namespace views {
 namespace {
 
 // The scale factor to compute the large size of the default
 // SquareInkDropRipple.
 const float kLargeInkDropScale = 1.333f;
 
 // Default opacity of the ink drop when it is visible.
-const float kInkDropVisibleOpacity = 0.175f;
+float DefaultInkDropVisibleOpacity() {
+  constexpr float kInkDropVisibleOpacity = 0.175f;
+  constexpr float kInkDropVisibleOpacityMd = 0.05f;
+  return ui::MaterialDesignController::IsSecondaryUiMaterial()
+             ? kInkDropVisibleOpacityMd
+             : kInkDropVisibleOpacity;
+}
 
 }  // namespace
 
 // static
 constexpr int InkDropHostView::kInkDropSmallCornerRadius;
 constexpr int InkDropHostView::kInkDropLargeCornerRadius;
 
 // An EventHandler that is guaranteed to be invoked and is not prone to
 // InkDropHostView descendents who do not call
 // InkDropHostView::OnGestureEvent().  Only one instance of this class can exist
@@ skipping 72 matching lines @@
 // static
 
 gfx::Size InkDropHostView::CalculateLargeInkDropSize(
     const gfx::Size& small_size) {
   return gfx::ScaleToCeiledSize(gfx::Size(small_size), kLargeInkDropScale);
 }
 
 InkDropHostView::InkDropHostView()
     : ink_drop_mode_(InkDropMode::OFF),
       ink_drop_(nullptr),
-      ink_drop_visible_opacity_(kInkDropVisibleOpacity),
+      ink_drop_visible_opacity_(DefaultInkDropVisibleOpacity()),
       old_paint_to_layer_(false),
       destroying_(false) {}
 
 InkDropHostView::~InkDropHostView() {
   // TODO(bruthig): Improve InkDropImpl to be safer about calling back to
   // potentially destroyed InkDropHosts and remove |destroying_|.
   destroying_ = true;
 }
 
 void InkDropHostView::AddInkDropLayer(ui::Layer* ink_drop_layer) {
@@ skipping 33 matching lines @@
     const {
   return CreateDefaultInkDropHighlight(
       gfx::RectF(GetMirroredRect(GetContentsBounds())).CenterPoint());
 }
 
 std::unique_ptr<InkDropRipple> InkDropHostView::CreateDefaultInkDropRipple(
     const gfx::Point& center_point,
     const gfx::Size& size) const {
   std::unique_ptr<InkDropRipple> ripple(new SquareInkDropRipple(
       CalculateLargeInkDropSize(size), kInkDropLargeCornerRadius, size,
-      kInkDropSmallCornerRadius, center_point, GetInkDropBaseColor(),
+      kInkDropSmallCornerRadius, center_point, GetInkDropBaseColorImpl(),
       ink_drop_visible_opacity()));
   return ripple;
 }
 
+std::unique_ptr<InkDropRipple> InkDropHostView::CreateFloodFillInkDropRipple()
+    const {
+  return std::unique_ptr<InkDropRipple>(new FloodFillInkDropRipple(
+      gfx::Size(kDefaultInkDropSize, kDefaultInkDropSize),
+      GetInkDropCenterBasedOnLastEvent(), GetInkDropBaseColorImpl(),
+      ink_drop_visible_opacity()));
+}
+
 std::unique_ptr<InkDropHighlight>
 InkDropHostView::CreateDefaultInkDropHighlight(const gfx::PointF& center_point,
                                                const gfx::Size& size) const {
-  std::unique_ptr<InkDropHighlight> highlight(new InkDropHighlight(
-      size, kInkDropSmallCornerRadius, center_point, GetInkDropBaseColor()));
+  std::unique_ptr<InkDropHighlight> highlight(
+      new InkDropHighlight(size, kInkDropSmallCornerRadius, center_point,
+                           GetInkDropBaseColorImpl()));
   highlight->set_explode_size(gfx::SizeF(CalculateLargeInkDropSize(size)));
   return highlight;
 }
 
 void InkDropHostView::SetInkDropMode(InkDropMode ink_drop_mode) {
   ink_drop_mode_ = ink_drop_mode;
   ink_drop_ = nullptr;
 
   if (ink_drop_mode_ != InkDropMode::ON)
     gesture_handler_ = nullptr;
@@ skipping 114 matching lines @@
 
 std::unique_ptr<InkDropImpl>
 InkDropHostView::CreateDefaultFloodFillInkDropImpl() {
   std::unique_ptr<views::InkDropImpl> ink_drop =
       InkDropHostView::CreateDefaultInkDropImpl();
   ink_drop->SetAutoHighlightMode(
       views::InkDropImpl::AutoHighlightMode::SHOW_ON_RIPPLE);
   return ink_drop;
 }
 
+SkColor InkDropHostView::GetInkDropBaseColorImpl() const {
+  return ui::MaterialDesignController::IsSecondaryUiMaterial()
+             ? SK_ColorBLACK
+             : GetInkDropBaseColor();
+}
+
 }  // namespace views