Refactoring for the InputMethod & InputMethodDelegate interfaces.

ui/base/ime/remote_input_method_win_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/base/ime/remote_input_method_win.h"
 
 #include <InputScope.h>
 
 #include <vector>
 
@@ skipping 120 matching lines @@
   MockInputMethodDelegate() {}
 
   const std::vector<ui::KeyboardCode>& fabricated_key_events() const {
     return fabricated_key_events_;
   }
   void Reset() {
     fabricated_key_events_.clear();
   }
 
  private:
-  bool DispatchKeyEventPostIME(const ui::KeyEvent& event) override {
-    EXPECT_FALSE(event.HasNativeEvent());
-    fabricated_key_events_.push_back(event.key_code());
-    return true;
+  ui::EventDispatchDetails DispatchKeyEventPostIME(
+      ui::KeyEvent* event) override {
+    EXPECT_FALSE(event->HasNativeEvent());
+    fabricated_key_events_.push_back(event->key_code());
+    return ui::EventDispatchDetails();
   }
 
   std::vector<ui::KeyboardCode> fabricated_key_events_;
   DISALLOW_COPY_AND_ASSIGN(MockInputMethodDelegate);
 };
 
 class MockRemoteInputMethodDelegateWin
     : public internal::RemoteInputMethodDelegateWin {
  public:
   MockRemoteInputMethodDelegateWin()
@@ skipping 354 matching lines @@
   // Basically RemoteInputMethodWin does not handle native keydown event.
 
   MockInputMethodDelegate delegate_;
   MockTextInputClient mock_text_input_client;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 
   const MSG wm_keydown = { NULL, WM_KEYDOWN, ui::VKEY_A };
   ui::KeyEvent native_keydown(wm_keydown);
 
   // This must not cause a crash.
-  EXPECT_FALSE(input_method->DispatchKeyEvent(native_keydown));
+  input_method->DispatchKeyEvent(&native_keydown);

[yukawa, 2015/07/30 18:11:39]

Does it make sense to check |native_keydown.handled()|?  Ditto for other test
cases.

[Shu Chen, 2015/07/31 01:18:47]

Yes, makes sense. Thanks for catching this.

   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   RemoteInputMethodPrivateWin* private_ptr =
       RemoteInputMethodPrivateWin::Get(input_method.get());
   ASSERT_TRUE(private_ptr != NULL);
   MockRemoteInputMethodDelegateWin mock_remote_delegate;
   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 
   // TextInputClient is not focused yet here.
 
-  EXPECT_FALSE(input_method->DispatchKeyEvent(native_keydown));
+  input_method->DispatchKeyEvent(&native_keydown);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 
   // TextInputClient is now focused here.
 
-  EXPECT_FALSE(input_method->DispatchKeyEvent(native_keydown));
+  input_method->DispatchKeyEvent(&native_keydown);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 }
 
 TEST(RemoteInputMethodWinTest, DispatchKeyEvent_NativeCharEvent) {
   // RemoteInputMethodWin handles native char event if possible.
 
   MockInputMethodDelegate delegate_;
   MockTextInputClient mock_text_input_client;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 
   const MSG wm_char = { NULL, WM_CHAR, 'A', 0 };
   ui::KeyEvent native_char(wm_char);
 
   // This must not cause a crash.
-  EXPECT_FALSE(input_method->DispatchKeyEvent(native_char));
+  input_method->DispatchKeyEvent(&native_char);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   RemoteInputMethodPrivateWin* private_ptr =
       RemoteInputMethodPrivateWin::Get(input_method.get());
   ASSERT_TRUE(private_ptr != NULL);
   MockRemoteInputMethodDelegateWin mock_remote_delegate;
   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 
   // TextInputClient is not focused yet here.
 
-  EXPECT_FALSE(input_method->DispatchKeyEvent(native_char));
+  input_method->DispatchKeyEvent(&native_char);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 
   // TextInputClient is now focused here.
 
-  EXPECT_TRUE(input_method->DispatchKeyEvent(native_char));
+  input_method->DispatchKeyEvent(&native_char);
   EXPECT_EQ(L"A", mock_text_input_client.inserted_text());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 }
 
 TEST(RemoteInputMethodWinTest, DispatchKeyEvent_FabricatedKeyDown) {
   // Fabricated non-char event will be delegated to
   // InputMethodDelegate::DispatchFabricatedKeyEventPostIME as long as the
   // delegate is installed.
 
   MockInputMethodDelegate delegate_;
   MockTextInputClient mock_text_input_client;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 
   ui::KeyEvent fabricated_keydown(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_NONE);
   fabricated_keydown.set_character(L'A');
 
   // This must not cause a crash.
-  EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_keydown));
+  input_method->DispatchKeyEvent(&fabricated_keydown);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   ASSERT_EQ(1, delegate_.fabricated_key_events().size());
   EXPECT_EQ(L'A', delegate_.fabricated_key_events()[0]);
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   RemoteInputMethodPrivateWin* private_ptr =
       RemoteInputMethodPrivateWin::Get(input_method.get());
   ASSERT_TRUE(private_ptr != NULL);
   MockRemoteInputMethodDelegateWin mock_remote_delegate;
   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 
   // TextInputClient is not focused yet here.
 
-  EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_keydown));
+  input_method->DispatchKeyEvent(&fabricated_keydown);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   ASSERT_EQ(1, delegate_.fabricated_key_events().size());
   EXPECT_EQ(L'A', delegate_.fabricated_key_events()[0]);
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   input_method->SetFocusedTextInputClient(&mock_text_input_client);
   // TextInputClient is now focused here.
 
-  EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_keydown));
+  input_method->DispatchKeyEvent(&fabricated_keydown);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   ASSERT_EQ(1, delegate_.fabricated_key_events().size());
   EXPECT_EQ(L'A', delegate_.fabricated_key_events()[0]);
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   input_method->SetDelegate(NULL);
   // RemoteInputMethodDelegateWin is no longer set here.
 
-  EXPECT_FALSE(input_method->DispatchKeyEvent(fabricated_keydown));
+  input_method->DispatchKeyEvent(&fabricated_keydown);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 }
 
 TEST(RemoteInputMethodWinTest, DispatchKeyEvent_FabricatedChar) {
   // Note: RemoteInputMethodWin::DispatchKeyEvent should always return true
   // for fabricated character events.
 
   MockInputMethodDelegate delegate_;
   MockTextInputClient mock_text_input_client;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 
   ui::KeyEvent fabricated_char(L'A', ui::VKEY_A, ui::EF_NONE);
 
   // This must not cause a crash.
-  EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
+  input_method->DispatchKeyEvent(&fabricated_char);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   RemoteInputMethodPrivateWin* private_ptr =
       RemoteInputMethodPrivateWin::Get(input_method.get());
   ASSERT_TRUE(private_ptr != NULL);
   MockRemoteInputMethodDelegateWin mock_remote_delegate;
   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 
   // TextInputClient is not focused yet here.
 
-  EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
+  input_method->DispatchKeyEvent(&fabricated_char);
   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 
   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 
   // TextInputClient is now focused here.
 
-  EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
+  input_method->DispatchKeyEvent(&fabricated_char);
   EXPECT_EQ(L"A", mock_text_input_client.inserted_text());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 }
 
 TEST(RemoteInputMethodWinTest, OnCompositionChanged) {
   MockInputMethodDelegate delegate_;
   MockTextInputClient mock_text_input_client;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
@@ skipping 112 matching lines @@
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
   input_method->AddObserver(&input_method_observer);
 
   EXPECT_EQ(0u, input_method_observer.on_input_method_destroyed_changed());
   input_method.reset();
   EXPECT_EQ(1u, input_method_observer.on_input_method_destroyed_changed());
 }
 
 }  // namespace
 }  // namespace ui