Refactoring for InputMethodEngine and InputMethodEventRouter.

chrome/browser/chromeos/input_method/input_method_engine_unittest.cc

 // Copyright 2014 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 "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine_interface.h"
 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/mock_component_extension_ime_manager_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ime/chromeos/mock_ime_input_context_handler.h"
 
 namespace chromeos {
 
 namespace input_method {
 namespace {
 
 const char kTestExtensionId[] = "mppnpdlheglhdfmldimlhpnegondlapf";
 const char kTestExtensionId2[] = "dmpipdbjkoajgdeppkffbjhngfckdloi";
-const char kTestImeEngineId[] = "test_engine_id";
+const char kTestImeComponentId[] = "test_engine_id";
 
 const char* kHistogramNames[] = {
     "InputMethod.Enable.test_engine_id", "InputMethod.Commit.test_engine_id",
     "InputMethod.CommitCharacter.test_engine_id",
 };
 
 scoped_ptr<base::HistogramSamples> GetHistogramSamples(
     const char* histogram_name) {
   base::HistogramBase* histogram =
       base::StatisticsRecorder::FindHistogram(histogram_name);
@@ skipping 12 matching lines @@
 void InitInputMethod() {
   ComponentExtensionIMEManager* comp_ime_manager =
       new ComponentExtensionIMEManager;
   MockComponentExtIMEManagerDelegate* delegate =
       new MockComponentExtIMEManagerDelegate;
 
   ComponentExtensionIME ext1;
   ext1.id = kTestExtensionId;
 
   ComponentExtensionEngine ext1_engine1;
-  ext1_engine1.engine_id = kTestImeEngineId;
+  ext1_engine1.engine_id = kTestImeComponentId;
   ext1_engine1.language_codes.push_back("en-US");
   ext1_engine1.layouts.push_back("us");
   ext1.engines.push_back(ext1_engine1);
 
   std::vector<ComponentExtensionIME> ime_list;
   ime_list.push_back(ext1);
   delegate->set_ime_list(ime_list);
   comp_ime_manager->Initialize(
       scoped_ptr<ComponentExtensionIMEManagerDelegate>(delegate).Pass());
 
@@ skipping 99 matching lines @@
     scoped_ptr<base::HistogramSamples> delta_samples(
         GetHistogramSamplesDelta(histogram_name));
     EXPECT_EQ(total_count, delta_samples->TotalCount());
     EXPECT_EQ(sample_count, delta_samples->GetCount(sample));
   }
 
   void CreateEngine(bool whitelisted) {
     engine_.reset(new InputMethodEngine());
     observer_ = new TestObserver();
     scoped_ptr<InputMethodEngineInterface::Observer> observer_ptr(observer_);
-    engine_->Initialize(NULL /* profile */,
-                        observer_ptr.Pass(),
-                        "",
-                        whitelisted ? kTestExtensionId : kTestExtensionId2,
-                        kTestImeEngineId,
-                        languages_,
-                        layouts_,
-                        options_page_,
-                        input_view_);
+    engine_->Initialize(observer_ptr.Pass(),
+                        whitelisted ? kTestExtensionId : kTestExtensionId2);
   }
 
   void FocusIn(ui::TextInputType input_type) {
     IMEEngineHandlerInterface::InputContext input_context(
         input_type, ui::TEXT_INPUT_MODE_DEFAULT);
     engine_->FocusIn(input_context);
     IMEBridge::Get()->SetCurrentTextInputType(input_type);
   }
 
   scoped_ptr<InputMethodEngine> engine_;
@@ skipping 14 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InputMethodEngineTest);
 };
 
 }  // namespace
 
 TEST_F(InputMethodEngineTest, TestSwitching) {
   CreateEngine(false);
   // Enable/disable with focus.
   FocusIn(ui::TEXT_INPUT_TYPE_URL);
   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->Disable();
   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
   // Enable/disable without focus.
   engine_->FocusOut();
   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->Disable();
   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
   // Focus change when enabled.
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->FocusOut();
   EXPECT_EQ(ONBLUR, observer_->GetCallsBitmapAndReset());
   // Focus change when disabled.
   engine_->Disable();
   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
   FocusIn(ui::TEXT_INPUT_TYPE_TEXT);
   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
   engine_->FocusOut();
   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 }
 
 TEST_F(InputMethodEngineTest, TestSwitching_Password_3rd_Party) {
   CreateEngine(false);
   // Enable/disable with focus.
   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->Disable();
   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
   // Focus change when enabled.
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->FocusOut();
   EXPECT_EQ(ONBLUR, observer_->GetCallsBitmapAndReset());
   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->Disable();
   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 }
 
 TEST_F(InputMethodEngineTest, TestSwitching_Password_Whitelisted) {
   CreateEngine(true);
   // Enable/disable with focus.
   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->Disable();
   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
   // Focus change when enabled.
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->FocusOut();
   EXPECT_EQ(ONBLUR, observer_->GetCallsBitmapAndReset());
   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(ONFOCUS, observer_->GetCallsBitmapAndReset());
   engine_->Disable();
   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 }
 
 TEST_F(InputMethodEngineTest, TestHistograms) {
   CreateEngine(true);
   FocusIn(ui::TEXT_INPUT_TYPE_TEXT);
-  engine_->Enable();
+  engine_->Enable(kTestImeComponentId);
   std::string error;
   ExpectNewSample("InputMethod.Enable.test_engine_id", 1, 1, 1);
   engine_->CommitText(1, "input", &error);
   engine_->CommitText(1, "入力", &error);
   engine_->CommitText(1, "input入力", &error);
   ExpectNewSample("InputMethod.Commit.test_engine_id", 1, 3, 3);
   ExpectNewSample("InputMethod.CommitCharacter.test_engine_id", 5, 3, 1);
   ExpectNewSample("InputMethod.CommitCharacter.test_engine_id", 2, 3, 1);
   ExpectNewSample("InputMethod.CommitCharacter.test_engine_id", 7, 3, 1);
 }
 
 }  // namespace input_method
 }  // namespace chromeos