diff --git a/chrome/browser/ash/arc/input_method_manager/arc_input_method_manager_service.cc b/chrome/browser/ash/arc/input_method_manager/arc_input_method_manager_service.cc index 2d8c280737de81..5e28af147e82ec 100644 --- a/chrome/browser/ash/arc/input_method_manager/arc_input_method_manager_service.cc +++ b/chrome/browser/ash/arc/input_method_manager/arc_input_method_manager_service.cc @@ -247,10 +247,10 @@ class ArcInputMethodManagerService::InputMethodEngineObserver // events here to make sure that Android side receives "keyup" events // always to prevent never-ending key repeat from happening. owner_->SendHideVirtualKeyboard(); - std::move(key_data).Run(true); + std::move(key_data).Run(ui::ime::KeyEventHandledState::kHandledByIME); return; } - std::move(key_data).Run(false); + std::move(key_data).Run(ui::ime::KeyEventHandledState::kNotHandled); } void OnReset(const std::string& engine_id) override {} void OnDeactivated(const std::string& engine_id) override { diff --git a/chrome/browser/ash/input_method/input_method_engine.cc b/chrome/browser/ash/input_method/input_method_engine.cc index 4e91ea01cfdec6..a87a0190e2f79a 100644 --- a/chrome/browser/ash/input_method/input_method_engine.cc +++ b/chrome/browser/ash/input_method/input_method_engine.cc @@ -577,7 +577,9 @@ void InputMethodEngine::KeyEventHandled(const std::string& extension_id, return; } - std::move(it->second.callback).Run(handled); + std::move(it->second.callback) + .Run(handled ? ui::ime::KeyEventHandledState::kHandledByIME + : ui::ime::KeyEventHandledState::kNotHandled); pending_key_events_.erase(it); } @@ -595,7 +597,8 @@ std::string InputMethodEngine::AddPendingKeyEvent( void InputMethodEngine::CancelPendingKeyEvents() { for (auto& event : pending_key_events_) { - std::move(event.second.callback).Run(false); + std::move(event.second.callback) + .Run(ui::ime::KeyEventHandledState::kNotHandled); } pending_key_events_.clear(); } @@ -669,7 +672,7 @@ void InputMethodEngine::Reset() { void InputMethodEngine::ProcessKeyEvent(const ui::KeyEvent& key_event, KeyEventDoneCallback callback) { if (key_event.IsCommandDown()) { - std::move(callback).Run(false); + std::move(callback).Run(ui::ime::KeyEventHandledState::kNotHandled); return; } @@ -681,11 +684,12 @@ void InputMethodEngine::ProcessKeyEvent(const ui::KeyEvent& key_event, active_component_id_, key_event, base::BindOnce( [](base::Time start, int context_id, int* context_id_ptr, - KeyEventDoneCallback callback, bool handled) { + KeyEventDoneCallback callback, + ui::ime::KeyEventHandledState handled_state) { // If the input_context has changed, assume the key event is // invalid as a precaution. if (context_id == *context_id_ptr) { - std::move(callback).Run(handled); + std::move(callback).Run(handled_state); } UMA_HISTOGRAM_TIMES("InputMethod.KeyEventLatency", base::Time::Now() - start); diff --git a/chrome/browser/ash/input_method/input_method_engine_browsertests.cc b/chrome/browser/ash/input_method/input_method_engine_browsertests.cc index a99b7967a78d34..41e2545eb1ac66 100644 --- a/chrome/browser/ash/input_method/input_method_engine_browsertests.cc +++ b/chrome/browser/ash/input_method/input_method_engine_browsertests.cc @@ -137,7 +137,7 @@ class InputMethodEngineBrowserTest class KeyEventDoneCallback { public: - explicit KeyEventDoneCallback(bool expected_argument) + explicit KeyEventDoneCallback(ui::ime::KeyEventHandledState expected_argument) : expected_argument_(expected_argument) {} KeyEventDoneCallback(const KeyEventDoneCallback&) = delete; @@ -145,7 +145,7 @@ class KeyEventDoneCallback { ~KeyEventDoneCallback() = default; - void Run(bool consumed) { + void Run(ui::ime::KeyEventHandledState consumed) { if (consumed == expected_argument_) run_loop_.Quit(); } @@ -153,7 +153,7 @@ class KeyEventDoneCallback { void WaitUntilCalled() { run_loop_.Run(); } private: - bool expected_argument_; + ui::ime::KeyEventHandledState expected_argument_; base::RunLoop run_loop_; }; @@ -228,7 +228,9 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, BasicScenarioTest) { ASSERT_TRUE(focus_listener.was_satisfied()); // onKeyEvent should be fired if ProcessKeyEvent is called. - KeyEventDoneCallback callback(false); // EchoBackIME doesn't consume keys. + KeyEventDoneCallback callback( + ui::ime::KeyEventHandledState::kNotHandled); // EchoBackIME doesn't + // consume keys. ExtensionTestMessageListener keyevent_listener("onKeyEvent"); ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_NONE); ui::IMEEngineHandlerInterface::KeyEventDoneCallback keyevent_callback = @@ -310,7 +312,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { { SCOPED_TRACE("KeyDown, Ctrl:No, Alt:No, AltGr:No, Shift:No, Caps:No"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:a:KeyA:false:false:false:false:false"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -326,7 +328,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { } { SCOPED_TRACE("KeyDown, Ctrl:Yes, Alt:No, AltGr:No, Shift:No, Caps:No"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:a:KeyA:true:false:false:false:false"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -342,7 +344,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { } { SCOPED_TRACE("KeyDown, Ctrl:No, Alt:Yes, AltGr:No, Shift:No, Caps:No"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:a:KeyA:false:true:false:false:false"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -358,7 +360,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { } { SCOPED_TRACE("KeyDown, Ctrl:No, Alt:No, AltGr:No, Shift:Yes, Caps:No"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:A:KeyA:false:false:false:true:false"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -374,7 +376,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { } { SCOPED_TRACE("KeyDown, Ctrl:No, Alt:No, AltGr:No, Shift:No, Caps:Yes"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:A:KeyA:false:false:false:false:true"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -390,7 +392,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { } { SCOPED_TRACE("KeyDown, Ctrl:Yes, Alt:Yes, AltGr:No, Shift:No, Caps:No"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:a:KeyA:true:true:false:false:false"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -406,7 +408,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { } { SCOPED_TRACE("KeyDown, Ctrl:No, Alt:No, AltGr:No, Shift:Yes, Caps:Yes"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:a:KeyA:false:false:false:true:true"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -422,7 +424,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { } { SCOPED_TRACE("KeyDown, Ctrl:No, Alt:No, AltGr:Yes, Shift:No, Caps:No"); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = "onKeyEvent::true:keydown:a:KeyA:false:false:true:false:false"; ExtensionTestMessageListener keyevent_listener(expected_value); @@ -467,7 +469,7 @@ IN_PROC_BROWSER_TEST_P(InputMethodEngineBrowserTest, APIArgumentTest) { for (size_t i = 0; i < std::size(kMediaKeyCases); ++i) { SCOPED_TRACE(std::string("KeyDown, ") + kMediaKeyCases[i].code); - KeyEventDoneCallback callback(false); + KeyEventDoneCallback callback(ui::ime::KeyEventHandledState::kNotHandled); const std::string expected_value = base::StringPrintf( "onKeyEvent::true:keydown:%s:%s:false:false:false:false:false", kMediaKeyCases[i].key, kMediaKeyCases[i].code); diff --git a/chrome/browser/ash/input_method/input_method_engine_unittest.cc b/chrome/browser/ash/input_method/input_method_engine_unittest.cc index 7c36be107396e3..24a5232a23b806 100644 --- a/chrome/browser/ash/input_method/input_method_engine_unittest.cc +++ b/chrome/browser/ash/input_method/input_method_engine_unittest.cc @@ -106,7 +106,7 @@ class TestObserver : public StubInputMethodEngineObserver { const std::string& engine_id, const ui::KeyEvent& event, ui::IMEEngineHandlerInterface::KeyEventDoneCallback callback) override { - std::move(callback).Run(/* handled */ true); + std::move(callback).Run(ui::ime::KeyEventHandledState::kHandledByIME); } void OnCompositionBoundsChanged( const std::vector& bounds) override { diff --git a/chrome/browser/ash/input_method/native_input_method_engine_observer.cc b/chrome/browser/ash/input_method/native_input_method_engine_observer.cc index 1eee625f7b27f6..9eb122997d4830 100644 --- a/chrome/browser/ash/input_method/native_input_method_engine_observer.cc +++ b/chrome/browser/ash/input_method/native_input_method_engine_observer.cc @@ -794,17 +794,17 @@ void NativeInputMethodEngineObserver::OnKeyEvent( ui::IMEEngineHandlerInterface::KeyEventDoneCallback callback) { if (assistive_suggester_->IsAssistiveFeatureEnabled()) { if (assistive_suggester_->OnKeyEvent(event)) { - std::move(callback).Run(true); + std::move(callback).Run(ui::ime::KeyEventHandledState::kHandledByIME); return; } } if (autocorrect_manager_->OnKeyEvent(event)) { - std::move(callback).Run(true); + std::move(callback).Run(ui::ime::KeyEventHandledState::kHandledByIME); return; } if (grammar_manager_->IsOnDeviceGrammarEnabled() && grammar_manager_->OnKeyEvent(event)) { - std::move(callback).Run(true); + std::move(callback).Run(ui::ime::KeyEventHandledState::kHandledByIME); return; } @@ -818,20 +818,20 @@ void NativeInputMethodEngineObserver::OnKeyEvent( // Don't send dead keys to the system IME. Dead keys should be handled at // the OS level and not exposed to IMEs. if (event.GetDomKey().IsDeadKey()) { - std::move(callback).Run(true); + std::move(callback).Run(ui::ime::KeyEventHandledState::kHandledByIME); return; } mojom::PhysicalKeyEventPtr key_event = CreatePhysicalKeyEventFromKeyEvent(event); if (!key_event) { - std::move(callback).Run(false); + std::move(callback).Run(ui::ime::KeyEventHandledState::kNotHandled); return; } // Hot switches to turn on/off certain IME features. if (IsFstEngine(engine_id) && autocorrect_manager_->DisabledByRule()) { - std::move(callback).Run(false); + std::move(callback).Run(ui::ime::KeyEventHandledState::kNotHandled); return; } @@ -847,14 +847,16 @@ void NativeInputMethodEngineObserver::OnKeyEvent( original_callback, mojom::KeyEventResult result) { std::move(original_callback) - .Run(result == mojom::KeyEventResult::kConsumedByIme); + .Run((result == mojom::KeyEventResult::kConsumedByIme) + ? ui::ime::KeyEventHandledState::kHandledByIME + : ui::ime::KeyEventHandledState::kNotHandled); }, std::move(callback)); input_method_->ProcessKeyEvent(std::move(key_event), std::move(process_key_event_callback)); } else { - std::move(callback).Run(false); + std::move(callback).Run(ui::ime::KeyEventHandledState::kNotHandled); } } else { ime_base_observer_->OnKeyEvent(engine_id, event, std::move(callback)); diff --git a/chrome/browser/ash/input_method/native_input_method_engine_with_ime_service_browsertest.cc b/chrome/browser/ash/input_method/native_input_method_engine_with_ime_service_browsertest.cc index e34459c9397883..8e497210946133 100644 --- a/chrome/browser/ash/input_method/native_input_method_engine_with_ime_service_browsertest.cc +++ b/chrome/browser/ash/input_method/native_input_method_engine_with_ime_service_browsertest.cc @@ -31,7 +31,7 @@ class TestObserver : public StubInputMethodEngineObserver { const std::string& engine_id, const ui::KeyEvent& event, ui::IMEEngineHandlerInterface::KeyEventDoneCallback callback) override { - std::move(callback).Run(/*handled=*/false); + std::move(callback).Run(ui::ime::KeyEventHandledState::kNotHandled); } }; @@ -42,7 +42,9 @@ class KeyProcessingWaiter { base::Unretained(this)); } - void OnKeyEventDone(bool consumed) { run_loop_.Quit(); } + void OnKeyEventDone(ui::ime::KeyEventHandledState handled_state) { + run_loop_.Quit(); + } void Wait() { run_loop_.Run(); } diff --git a/chrome/browser/ash/input_method/native_input_method_engine_without_ime_service_browsertest.cc b/chrome/browser/ash/input_method/native_input_method_engine_without_ime_service_browsertest.cc index 36635b6651ac88..cd6e07c85c4464 100644 --- a/chrome/browser/ash/input_method/native_input_method_engine_without_ime_service_browsertest.cc +++ b/chrome/browser/ash/input_method/native_input_method_engine_without_ime_service_browsertest.cc @@ -64,7 +64,7 @@ class TestObserver : public StubInputMethodEngineObserver { const std::string& engine_id, const ui::KeyEvent& event, ui::IMEEngineHandlerInterface::KeyEventDoneCallback callback) override { - std::move(callback).Run(/*handled=*/false); + std::move(callback).Run(ui::ime::KeyEventHandledState::kNotHandled); } void OnInputMethodOptionsChanged(const std::string& engine_id) override { changed_engine_id_ = engine_id; @@ -105,7 +105,9 @@ class KeyProcessingWaiter { base::Unretained(this)); } - void OnKeyEventDone(bool consumed) { run_loop_.Quit(); } + void OnKeyEventDone(ui::ime::KeyEventHandledState handled_state) { + run_loop_.Quit(); + } void Wait() { run_loop_.Run(); } diff --git a/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc b/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc index ca3da1be815e3e..be0ba0fddb665c 100644 --- a/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc +++ b/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc @@ -335,7 +335,7 @@ class ImeObserverChromeOS if (!ShouldForwardKeyEvent()) { // Continue processing the key event so that the physical keyboard can // still work. - std::move(callback).Run(false); + std::move(callback).Run(ui::ime::KeyEventHandledState::kNotHandled); return; } diff --git a/ui/base/ime/ash/ime_engine_handler_interface.h b/ui/base/ime/ash/ime_engine_handler_interface.h index ee16207929f045..f2d5838798a035 100644 --- a/ui/base/ime/ash/ime_engine_handler_interface.h +++ b/ui/base/ime/ash/ime_engine_handler_interface.h @@ -30,12 +30,17 @@ class KeyEvent; namespace ime { struct AssistiveWindowButton; +enum class KeyEventHandledState { + kNotHandled = 0, + kHandledByIME = 1, +}; } // namespace ime // A interface to handle the engine handler method call. class COMPONENT_EXPORT(UI_BASE_IME_ASH) IMEEngineHandlerInterface { public: - using KeyEventDoneCallback = base::OnceCallback; + using KeyEventDoneCallback = + base::OnceCallback; // A information about a focused text input field. // A type of each member is based on the html spec, but InputContext can be diff --git a/ui/base/ime/ash/input_method_ash.cc b/ui/base/ime/ash/input_method_ash.cc index 30737060224710..9e129a562a0a2b 100644 --- a/ui/base/ime/ash/input_method_ash.cc +++ b/ui/base/ime/ash/input_method_ash.cc @@ -150,8 +150,13 @@ ui::EventDispatchDetails InputMethodAsh::DispatchKeyEvent(ui::KeyEvent* event) { return ui::EventDispatchDetails(); } -void InputMethodAsh::ProcessKeyEventDone(ui::KeyEvent* event, bool is_handled) { +void InputMethodAsh::ProcessKeyEventDone( + ui::KeyEvent* event, + ui::ime::KeyEventHandledState handled_state) { DCHECK(event); + bool is_handled = + (handled_state == ui::ime::KeyEventHandledState::kHandledByIME); + if (event->type() == ET_KEY_PRESSED) { if (is_handled) { // IME event has a priority to be handled, so that character composer diff --git a/ui/base/ime/ash/input_method_ash.h b/ui/base/ime/ash/input_method_ash.h index 9f20178c7a5d36..ab1df58a438532 100644 --- a/ui/base/ime/ash/input_method_ash.h +++ b/ui/base/ime/ash/input_method_ash.h @@ -22,6 +22,10 @@ namespace ui { +namespace ime { +enum class KeyEventHandledState; +} + // A `ui::InputMethod` implementation for Ash. class COMPONENT_EXPORT(UI_BASE_IME_ASH) InputMethodAsh : public InputMethodBase, @@ -171,7 +175,8 @@ class COMPONENT_EXPORT(UI_BASE_IME_ASH) InputMethodAsh TextInputMode GetTextInputMode() const; // Called from the engine when it completes processing. - void ProcessKeyEventDone(ui::KeyEvent* event, bool is_handled); + void ProcessKeyEventDone(ui::KeyEvent* event, + ui::ime::KeyEventHandledState handled_state); bool IsPasswordOrNoneInputFieldFocused(); diff --git a/ui/base/ime/ash/input_method_ash_unittest.cc b/ui/base/ime/ash/input_method_ash_unittest.cc index bee6c3c7442cd8..a6ca13a67ae1bc 100644 --- a/ui/base/ime/ash/input_method_ash_unittest.cc +++ b/ui/base/ime/ash/input_method_ash_unittest.cc @@ -1026,7 +1026,8 @@ TEST_F(InputMethodAshKeyEventTest, KeyEventDelayResponseTest) { EXPECT_EQ(0, inserted_char_); // Do callback. - std::move(mock_ime_engine_handler_->last_passed_callback()).Run(true); + std::move(mock_ime_engine_handler_->last_passed_callback()) + .Run(ui::ime::KeyEventHandledState::kHandledByIME); // Check the results EXPECT_EQ(1, input_method_ash_->process_key_event_post_ime_call_count()); @@ -1080,7 +1081,7 @@ TEST_F(InputMethodAshKeyEventTest, MultiKeyEventDelayResponseTest) { EXPECT_EQ(0, composition_text_.text[0]); // Do callback for first key event. - std::move(first_callback).Run(true); + std::move(first_callback).Run(ui::ime::KeyEventHandledState::kHandledByIME); EXPECT_EQ(comp.text, composition_text_.text); @@ -1094,7 +1095,8 @@ TEST_F(InputMethodAshKeyEventTest, MultiKeyEventDelayResponseTest) { EXPECT_EQ(0, inserted_char_); // Do callback for second key event. - mock_ime_engine_handler_->last_passed_callback().Run(false); + mock_ime_engine_handler_->last_passed_callback().Run( + ui::ime::KeyEventHandledState::kNotHandled); // Check the results for second key event. EXPECT_EQ(2, input_method_ash_->process_key_event_post_ime_call_count()); @@ -1116,7 +1118,8 @@ TEST_F(InputMethodAshKeyEventTest, StopPropagationTest) { ui::KeyEvent eventA(ui::ET_KEY_PRESSED, ui::VKEY_A, EF_NONE); eventA.set_character(L'A'); input_method_ash_->DispatchKeyEvent(&eventA); - mock_ime_engine_handler_->last_passed_callback().Run(false); + mock_ime_engine_handler_->last_passed_callback().Run( + ui::ime::KeyEventHandledState::kNotHandled); const ui::KeyEvent* key_event = mock_ime_engine_handler_->last_processed_key_event(); @@ -1126,7 +1129,8 @@ TEST_F(InputMethodAshKeyEventTest, StopPropagationTest) { // Do key event with event not being stopped propagation. stop_propagation_post_ime_ = false; input_method_ash_->DispatchKeyEvent(&eventA); - mock_ime_engine_handler_->last_passed_callback().Run(false); + mock_ime_engine_handler_->last_passed_callback().Run( + ui::ime::KeyEventHandledState::kNotHandled); key_event = mock_ime_engine_handler_->last_processed_key_event(); EXPECT_EQ(ui::VKEY_A, key_event->key_code()); @@ -1187,7 +1191,7 @@ TEST_F(InputMethodAshKeyEventTest, SetAutocorrectRangeRunsAfterKeyEvent) { input_method_ash_->DispatchKeyEvent(&event); input_method_ash_->SetAutocorrectRange(gfx::Range(0, 1)); std::move(mock_ime_engine_handler_->last_passed_callback()) - .Run(/*handled=*/true); + .Run(ui::ime::KeyEventHandledState::kHandledByIME); EXPECT_EQ(gfx::Range(0, 1), GetAutocorrectRange()); } @@ -1202,7 +1206,7 @@ TEST_F(InputMethodAshKeyEventTest, SetAutocorrectRangeRunsAfterCommitText) { u"a", TextInputClient::InsertTextCursorBehavior::kMoveCursorAfterText); input_method_ash_->SetAutocorrectRange(gfx::Range(0, 1)); std::move(mock_ime_engine_handler_->last_passed_callback()) - .Run(/*handled=*/true); + .Run(ui::ime::KeyEventHandledState::kHandledByIME); EXPECT_EQ(L'a', inserted_char_); EXPECT_EQ(gfx::Range(0, 1), GetAutocorrectRange()); @@ -1223,7 +1227,7 @@ TEST_F(InputMethodAshKeyEventTest, ime.CommitText( u"cde", TextInputClient::InsertTextCursorBehavior::kMoveCursorAfterText); std::move(mock_ime_engine_handler_->last_passed_callback()) - .Run(/*handled=*/true); + .Run(ui::ime::KeyEventHandledState::kHandledByIME); EXPECT_EQ(fake_text_input_client.text(), u"abcde"); EXPECT_EQ(fake_text_input_client.selection(), gfx::Range(5, 5)); @@ -1248,7 +1252,7 @@ TEST_F(InputMethodAshKeyEventTest, ime.CommitText( u"e", TextInputClient::InsertTextCursorBehavior::kMoveCursorAfterText); std::move(mock_ime_engine_handler_->last_passed_callback()) - .Run(/*handled=*/true); + .Run(ui::ime::KeyEventHandledState::kHandledByIME); EXPECT_EQ(fake_text_input_client.text(), u"bceda"); EXPECT_EQ(fake_text_input_client.selection(), gfx::Range(3, 3)); @@ -1267,7 +1271,7 @@ TEST_F(InputMethodAshKeyEventTest, CommitTextEmptyRunsAfterKeyEvent) { ime.CommitText( u"", TextInputClient::InsertTextCursorBehavior::kMoveCursorBeforeText); std::move(mock_ime_engine_handler_->last_passed_callback()) - .Run(/*handled=*/true); + .Run(ui::ime::KeyEventHandledState::kHandledByIME); EXPECT_EQ(fake_text_input_client.text(), u""); EXPECT_FALSE(fake_text_input_client.HasCompositionText()); @@ -1323,7 +1327,7 @@ TEST_F(InputMethodAshTest, CommitTextThenKeyEventOnlyInsertsOnce) { ui::KeyEvent key(ET_KEY_PRESSED, VKEY_A, EF_NONE); ime.DispatchKeyEvent(&key); std::move(mock_ime_engine_handler_->last_passed_callback()) - .Run(/*handled=*/true); + .Run(ui::ime::KeyEventHandledState::kHandledByIME); EXPECT_EQ(fake_text_input_client.text(), u"a"); }