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();

[sky, 2016/08/31 16:19:49]

If you don't call RequestFocus then how is Combobox::OnKeyPressed called?

[Evan Stade, 2016/08/31 21:12:29]

You'd still get keyboard focus if you tabbed to the combobox. When you click the
combobox the menu opens and takes focus anyway, so the only thing this changes
is appearance and where focus goes when the menu is closed.

[sky, 2016/08/31 21:53:04]

I thought clicking on Transparentbutton only gave focus to the combobox? Also,
if you don't give focus here subsequent key events after the menu is closed
won't target the combobox.

[Evan Stade, 2016/08/31 21:59:38]

Clicking on the transparent button gives focus to the combobox but the menu
immediately pops up and grabs focus.
That is correct. Do you think it's common to use the mouse then switch to the
keyboard? My understanding has been that with Harmony we don't want focus to
follow the mouse usually. We don't want visible focus effects after clicking and
if we created invisible focus I think that could be confusing.

+    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();

[sky, 2016/08/31 16:19:49]

Similar comment as to above.

 
   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