Add the button style for combobox

ui/views/controls/combobox/combobox_unittest.cc

 // Copyright 2013 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 <set>
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/models/combobox_model.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/views/controls/combobox/combobox_listener.h"
+#include "ui/views/controls/menu/menu_runner.h"
+#include "ui/views/controls/menu/menu_runner_core.h"
 #include "ui/views/ime/mock_input_method.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 
 namespace {
 
+// An dummy implementation of MenuRunnerCore to check if the dropdown menu is
+// shown or not.
+class TestMenuRunnerCore : public MenuRunnerCore {
+ public:
+  TestMenuRunnerCore()
+      : executed_(false) {}
+
+  bool executed() const { return executed_; }
+
+  virtual MenuRunner::RunResult RunMenuAt(Widget* parent,
+                                          MenuButton* button,
+                                          const gfx::Rect& bounds,
+                                          MenuItemView::AnchorPosition anchor,
+                                          ui::MenuSourceType source_type,
+                                          int32 types) OVERRIDE {
+    executed_ = true;
+    return MenuRunner::NORMAL_EXIT;
+  }
+
+ private:
+  bool executed_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestMenuRunnerCore);
+};
+
 // A wrapper of Combobox to intercept the result of OnKeyPressed() and
 // OnKeyReleased() methods.
 class TestCombobox : public Combobox {
  public:
   explicit TestCombobox(ui::ComboboxModel* model)
       : Combobox(model),
         key_handled_(false),
         key_received_(false) {
   }
 
@@ skipping 66 matching lines @@
   }
 
   bool deleted() const { return deleted_; }
 
  private:
   bool deleted_;
 
   DISALLOW_COPY_AND_ASSIGN(EvilListener);
 };
 
+class TestComboboxListener : public views::ComboboxListener {
+ public:
+  TestComboboxListener()
+      : on_selected_index_changed_called_(false),
+        on_combobox_text_button_clicked_called_(false) {
+  }
+  virtual ~TestComboboxListener() {}
+
+  virtual void OnSelectedIndexChanged(views::Combobox* combobox) OVERRIDE {
+    on_selected_index_changed_called_ = true;
+  }
+
+  virtual void OnComboboxTextButtonClicked(views::Combobox* combobox) OVERRIDE {
+    on_combobox_text_button_clicked_called_ = true;
+  }
+
+  bool on_selected_index_changed_called() const {
+    return on_selected_index_changed_called_;
+  }
+
+  bool on_combobox_text_button_clicked_called() const {
+    return on_combobox_text_button_clicked_called_;
+  }
+
+ private:
+  bool on_selected_index_changed_called_;
+  bool on_combobox_text_button_clicked_called_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestComboboxListener);
+};
+
 }  // namespace
 
 class ComboboxTest : public ViewsTestBase {
  public:
   ComboboxTest() : widget_(NULL), combobox_(NULL), input_method_(NULL) {}
 
   virtual void TearDown() OVERRIDE {
     if (widget_)
       widget_->Close();
     ViewsTestBase::TearDown();
   }
 
   void InitCombobox() {
     model_.reset(new TestComboboxModel());
 
     ASSERT_FALSE(combobox_);
     combobox_ = new TestCombobox(model_.get());
     combobox_->set_id(1);
 
     widget_ = new Widget;
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
-    params.bounds = gfx::Rect(100, 100, 100, 100);
+    params.bounds = gfx::Rect(200, 200, 200, 200);
     widget_->Init(params);
     View* container = new View();
     widget_->SetContentsView(container);
     container->AddChildView(combobox_);
 
     input_method_ = new MockInputMethod();
     widget_->ReplaceInputMethod(input_method_);
 
     // Assumes the Widget is always focused.
     input_method_->OnFocus();
 
     combobox_->RequestFocus();
+    combobox_->SizeToPreferredSize();
   }
 
  protected:
   void SendKeyEvent(ui::KeyboardCode key_code) {
-    ui::KeyEvent event(ui::ET_KEY_PRESSED, key_code, 0, false);
+    SendKeyEventWithType(key_code, ui::ET_KEY_PRESSED);
+  }
+
+  void SendKeyEventWithType(ui::KeyboardCode key_code, ui::EventType type) {
+    ui::KeyEvent event(type, key_code, 0, false);
     input_method_->DispatchKeyEvent(event);
   }
 
   View* GetFocusedView() {
     return widget_->GetFocusManager()->GetFocusedView();
   }
 
+  void PerformClick(const gfx::Point& point) {
+    ui::MouseEvent pressed_event = ui::MouseEvent(ui::ET_MOUSE_PRESSED, point,
+                                                  point,
+                                                  ui::EF_LEFT_MOUSE_BUTTON);
+    widget_->OnMouseEvent(&pressed_event);
+    ui::MouseEvent released_event = ui::MouseEvent(ui::ET_MOUSE_RELEASED, point,
+                                                   point,
+                                                   ui::EF_LEFT_MOUSE_BUTTON);
+    widget_->OnMouseEvent(&released_event);
+  }
+
   // We need widget to populate wrapper class.
   Widget* widget_;
 
   // |combobox_| will be allocated InitCombobox() and then owned by |widget_|.
   TestCombobox* combobox_;
 
   // Combobox does not take ownership of the model, hence it needs to be scoped.
   scoped_ptr<TestComboboxModel> model_;
 
   // For testing input method related behaviors.
@@ skipping 198 matching lines @@
 
 TEST_F(ComboboxTest, ListenerHandlesDelete) {
   TestComboboxModel model;
   TestCombobox* combobox = new TestCombobox(&model);  // Deleted on change.
   EvilListener evil_listener;
   combobox->set_listener(&evil_listener);
   ASSERT_NO_FATAL_FAILURE(combobox->ExecuteCommand(2));
   EXPECT_TRUE(evil_listener.deleted());
 }
 
+TEST_F(ComboboxTest, Click) {
+  InitCombobox();
+
+  TestComboboxListener listener;
+  combobox_->set_listener(&listener);
+
+  combobox_->Layout();
+
+  // Click the left side. The menu is shown.
+  TestMenuRunnerCore* menu_runner_core = new TestMenuRunnerCore();
+  combobox_->SetMenuRunnerCore(menu_runner_core);
+  PerformClick(gfx::Point(combobox_->x() + 1,
+                          combobox_->y() + combobox_->height() / 2));
+  EXPECT_FALSE(listener.on_combobox_text_button_clicked_called());
+  EXPECT_TRUE(menu_runner_core->executed());
+}
+
+TEST_F(ComboboxTest, NotifyOnClickWithReturnKey) {
+  InitCombobox();
+
+  TestComboboxListener listener;
+  combobox_->set_listener(&listener);
+
+  // With STYLE_SHOW_DROP_DOWN_ON_CLICK, the click event is ignored.
+  SendKeyEvent(ui::VKEY_RETURN);
+  EXPECT_FALSE(listener.on_combobox_text_button_clicked_called());
+
+  // With STYLE_NOTIFY_ON_CLICK, the click event is notified.
+  combobox_->SetStyle(Combobox::STYLE_NOTIFY_ON_CLICK);
+  SendKeyEvent(ui::VKEY_RETURN);
+  EXPECT_TRUE(listener.on_combobox_text_button_clicked_called());
+}
+
+TEST_F(ComboboxTest, NotifyOnClickWithSpaceKey) {
+  InitCombobox();
+
+  TestComboboxListener listener;
+  combobox_->set_listener(&listener);
+
+  // With STYLE_SHOW_DROP_DOWN_ON_CLICK, the click event is ignored.
+  SendKeyEvent(ui::VKEY_SPACE);
+  EXPECT_FALSE(listener.on_combobox_text_button_clicked_called());
+  SendKeyEventWithType(ui::VKEY_SPACE, ui::ET_KEY_RELEASED);
+  EXPECT_FALSE(listener.on_combobox_text_button_clicked_called());
+
+  // With STYLE_NOTIFY_ON_CLICK, the click event is notified after releasing.
+  combobox_->SetStyle(Combobox::STYLE_NOTIFY_ON_CLICK);
+  SendKeyEvent(ui::VKEY_SPACE);
+  EXPECT_FALSE(listener.on_combobox_text_button_clicked_called());
+  SendKeyEventWithType(ui::VKEY_SPACE, ui::ET_KEY_RELEASED);
+  EXPECT_TRUE(listener.on_combobox_text_button_clicked_called());
+}
+
+TEST_F(ComboboxTest, NotifyOnClickWithMouse) {
+  InitCombobox();
+
+  TestComboboxListener listener;
+  combobox_->set_listener(&listener);
+
+  combobox_->SetStyle(Combobox::STYLE_NOTIFY_ON_CLICK);
+  combobox_->Layout();
+
+  // Click the right side (arrow button). The menu is shown.
+  TestMenuRunnerCore* menu_runner_core = new TestMenuRunnerCore();
+  combobox_->SetMenuRunnerCore(menu_runner_core);
+  PerformClick(gfx::Point(combobox_->x() + combobox_->width() - 1,
+                          combobox_->y() + combobox_->height() / 2));
+  EXPECT_FALSE(listener.on_combobox_text_button_clicked_called());
+  EXPECT_TRUE(menu_runner_core->executed());
+
+  // Click the left side (text button). The click event is notified.
+  menu_runner_core = new TestMenuRunnerCore();
+  combobox_->SetMenuRunnerCore(menu_runner_core);
+  PerformClick(gfx::Point(combobox_->x() + 1,
+                          combobox_->y() + combobox_->height() / 2));
+  EXPECT_TRUE(listener.on_combobox_text_button_clicked_called());
+  EXPECT_FALSE(menu_runner_core->executed());
+}
+
 }  // namespace views