Add ink drop ripple (but no highlight) to comboboxes in harmony.

ui/views/controls/combobox/combobox.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/combobox/combobox.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/default_style.h"
 #include "ui/base/ime/input_method.h"
+#include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/models/combobox_model.h"
 #include "ui/base/models/combobox_model_observer.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/text_utils.h"
 #include "ui/native_theme/common_theme.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/resources/grit/ui_resources.h"
+#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
+#include "ui/views/animation/ink_drop_highlight.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/custom_button.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/combobox/combobox_listener.h"
 #include "ui/views/controls/focusable_border.h"
 #include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/prefix_selector.h"
 #include "ui/views/controls/textfield/textfield.h"
@@ skipping 41 matching lines @@
 const int kHoveredMenuButtonImages[] = MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_H);
 const int kPressedMenuButtonImages[] = MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_P);
 const int kFocusedMenuButtonImages[] = MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_F);
 const int kFocusedHoveredMenuButtonImages[] =
     MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_F_H);
 const int kFocusedPressedMenuButtonImages[] =
     MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_F_P);
 
 #undef MENU_IMAGE_GRID
 
+bool UseMd() {
+  return ui::MaterialDesignController::IsSecondaryUiMaterial();
+}
+
 gfx::Rect PositionArrowWithinContainer(const gfx::Rect& container_bounds,
                                        const gfx::Size& arrow_size,
                                        Combobox::Style style) {
   gfx::Rect bounds(container_bounds);
   if (style == Combobox::STYLE_ACTION) {
     // This positions the arrow horizontally. The later call to
     // ClampToCenteredSize will position it vertically without touching the
     // horizontal position.
     bounds.Inset(kActionLeftPadding, 0, kActionRightPadding, 0);
     DCHECK_EQ(bounds.width(), arrow_size.width());
   }
 
   bounds.ClampToCenteredSize(arrow_size);
   return bounds;
 }
 
 // The transparent button which holds a button state but is not rendered.
 class TransparentButton : public CustomButton {
  public:
   TransparentButton(ButtonListener* listener)
       : CustomButton(listener) {
     SetAnimationDuration(LabelButton::kHoverAnimationDurationMs);
     SetFocusBehavior(FocusBehavior::NEVER);
     set_notify_action(PlatformStyle::kMenuNotifyActivationAction);
+
+    if (UseMd()) {
+      SetInkDropMode(PlatformStyle::kUseRipples ? InkDropMode::ON
+                                                : InkDropMode::OFF);
+      set_has_ink_drop_action_on_click(true);
+    }
   }
   ~TransparentButton() override {}
 
-#if !defined(OS_MACOSX)
-  // Override OnMousePressed() to transfer focus to the parent() on a click
-  // except on Mac, which doesn't transfer focus when buttons are clicked.
   bool OnMousePressed(const ui::MouseEvent& mouse_event) override {
-    parent()->RequestFocus();
-    return true;
+    if (!UseMd())
+      parent()->RequestFocus();
+    return CustomButton::OnMousePressed(mouse_event);
   }
-#endif
 
   double GetAnimationValue() const {
     return hover_animation().GetCurrentValue();
   }
 
+  // Overridden from InkDropHost:
+  std::unique_ptr<InkDropRipple> CreateInkDropRipple() const override {
+    return std::unique_ptr<views::InkDropRipple>(
+        new views::FloodFillInkDropRipple(
+            GetLocalBounds(), GetInkDropCenterBasedOnLastEvent(),
+            GetNativeTheme()->GetSystemColor(
+                ui::NativeTheme::kColorId_LabelEnabledColor),
+            ink_drop_visible_opacity()));
+  }
+
+  std::unique_ptr<InkDropHighlight> CreateInkDropHighlight() const override {
+    return nullptr;
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(TransparentButton);
 };
 
 // Returns the next or previous valid index (depending on |increment|'s value).
 // Skips separator or disabled indices. Returns -1 if there is no valid adjacent
 // index.
 int GetAdjacentIndex(ui::ComboboxModel* model, int increment, int index) {
   DCHECK(increment == -1 || increment == 1);
 
@@ skipping 333 matching lines @@
   if (invalid == invalid_)
     return;
 
   invalid_ = invalid;
 
   UpdateBorder();
   SchedulePaint();
 }
 
 void Combobox::Layout() {
-  PrefixDelegate::Layout();
+  View::Layout();
 
   int text_button_width = 0;
   int arrow_button_width = 0;
 
   switch (style_) {
     case STYLE_NORMAL: {
       arrow_button_width = width();
       break;
     }
     case STYLE_ACTION: {
       arrow_button_width = GetArrowContainerWidth();
       text_button_width = width() - arrow_button_width;
       break;
     }
   }
 
   int arrow_button_x = std::max(0, text_button_width);
   text_button_->SetBounds(0, 0, std::max(0, text_button_width), height());
   arrow_button_->SetBounds(arrow_button_x, 0, arrow_button_width, height());
 }
 
 void Combobox::OnEnabledChanged() {
-  PrefixDelegate::OnEnabledChanged();
+  View::OnEnabledChanged();
   arrow_image_ = PlatformStyle::CreateComboboxArrow(enabled(), style_);
 }
 
 int Combobox::GetRowCount() {
   return model()->GetItemCount();
 }
 
 int Combobox::GetSelectedRow() {
   return selected_index_;
 }
@@ skipping 167 matching lines @@
   state->name = accessible_name_;
   state->value = model_->GetItemAt(selected_index_);
   state->index = selected_index_;
   state->count = model_->GetItemCount();
 }
 
 void Combobox::ButtonPressed(Button* sender, const ui::Event& event) {
   if (!enabled())
     return;
 
-  RequestFocus();
+  if (!UseMd())
+    RequestFocus();
 
   if (sender == text_button_) {
     OnPerformAction();
   } else {
     DCHECK_EQ(arrow_button_, sender);
     // TODO(hajimehoshi): Fix the problem that the arrow button blinks when
     // cliking this while the dropdown menu is opened.
     const base::TimeDelta delta = base::Time::Now() - closed_time_;
     if (delta.InMilliseconds() <= kMinimumMsBetweenButtonClicks)
       return;
@@ skipping 193 matching lines @@
     if (size_to_largest_label_ || i == selected_index_) {
       width = std::max(
           width, gfx::GetStringWidth(menu_model_->GetLabelAt(i), font_list));
     }
   }
   return gfx::Size(width, font_list.GetHeight());
 }
 
 PrefixSelector* Combobox::GetPrefixSelector() {
   if (!selector_)
-    selector_.reset(new PrefixSelector(this));
+    selector_.reset(new PrefixSelector(this, this));
   return selector_.get();
 }
 
 int Combobox::GetArrowContainerWidth() const {
   int padding = style_ == STYLE_NORMAL
                     ? PlatformStyle::kComboboxNormalArrowPadding * 2
                     : kActionLeftPadding + kActionRightPadding;
   return ArrowSize().width() + padding;
 }
 
 }  // namespace views