Move the local struct definitions off ui/base/ime.

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 "chrome/browser/chromeos/input_method/input_method_engine.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
+#include "chrome/browser/input_method/input_method_engine_base.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ime/chromeos/extension_ime_util.h"
 #include "ui/base/ime/chromeos/mock_component_extension_ime_manager_delegate.h"
 #include "ui/base/ime/chromeos/mock_ime_input_context_handler.h"
 #include "ui/base/ime/ime_bridge.h"
 #include "ui/base/ime/ime_engine_handler_interface.h"
-#include "ui/base/ime/ime_engine_observer.h"
 #include "ui/base/ime/text_input_flags.h"
 #include "ui/gfx/geometry/rect.h"
 
+using input_method::InputMethodEngineBase;
+
 namespace chromeos {
 
 namespace input_method {
 namespace {
 
 const char kTestExtensionId[] = "mppnpdlheglhdfmldimlhpnegondlapf";
 const char kTestExtensionId2[] = "dmpipdbjkoajgdeppkffbjhngfckdloi";
 const char kTestImeComponentId[] = "test_engine_id";
 
 enum CallsBitmap {
@@ skipping 25 matching lines @@
   delegate->set_ime_list(ime_list);
   comp_ime_manager->Initialize(
       scoped_ptr<ComponentExtensionIMEManagerDelegate>(delegate));
 
   MockInputMethodManager* manager = new MockInputMethodManager;
   manager->SetComponentExtensionIMEManager(
       scoped_ptr<ComponentExtensionIMEManager>(comp_ime_manager));
   InitializeForTesting(manager);
 }
 
-class TestObserver : public ui::IMEEngineObserver {
+class TestObserver : public InputMethodEngineBase::Observer {
  public:
   TestObserver() : calls_bitmap_(NONE) {}
   ~TestObserver() override {}
 
   void OnActivate(const std::string& engine_id) override {
     calls_bitmap_ |= ACTIVATE;
   }
   void OnDeactivated(const std::string& engine_id) override {
     calls_bitmap_ |= DEACTIVATED;
   }
   void OnFocus(
       const ui::IMEEngineHandlerInterface::InputContext& context) override {
     calls_bitmap_ |= ONFOCUS;
   }
   void OnBlur(int context_id) override { calls_bitmap_ |= ONBLUR; }
   bool IsInterestedInKeyEvent() const override { return true; }
   void OnKeyEvent(
       const std::string& engine_id,
-      const ui::IMEEngineHandlerInterface::KeyboardEvent& event,
+      const InputMethodEngineBase::KeyboardEvent& event,
       ui::IMEEngineHandlerInterface::KeyEventDoneCallback& key_data) override {}
   void OnInputContextUpdate(
       const ui::IMEEngineHandlerInterface::InputContext& context) override {}
-  void OnCandidateClicked(const std::string& engine_id,
-                          int candidate_id,
-                          MouseButtonEvent button) override {}
+  void OnCandidateClicked(
+      const std::string& engine_id,
+      int candidate_id,
+      InputMethodEngineBase::MouseButtonEvent button) override {}
   void OnMenuItemActivated(const std::string& engine_id,
                            const std::string& menu_id) override {}
   void OnSurroundingTextChanged(const std::string& engine_id,
                                 const std::string& text,
                                 int cursor_pos,
                                 int anchor_pos,
                                 int offset) override {}
   void OnCompositionBoundsChanged(
       const std::vector<gfx::Rect>& bounds) override {
     calls_bitmap_ |= ONCOMPOSITIONBOUNDSCHANGED;
@@ skipping 26 matching lines @@
   ~InputMethodEngineTest() override {
     ui::IMEBridge::Get()->SetInputContextHandler(NULL);
     engine_.reset();
     Shutdown();
   }
 
  protected:
   void CreateEngine(bool whitelisted) {
     engine_.reset(new InputMethodEngine());
     observer_ = new TestObserver();
-    scoped_ptr<ui::IMEEngineObserver> observer_ptr(observer_);
+    scoped_ptr<InputMethodEngineBase::Observer> observer_ptr(observer_);
     engine_->Initialize(std::move(observer_ptr),
                         whitelisted ? kTestExtensionId : kTestExtensionId2,
                         ProfileManager::GetActiveUserProfile());
   }
 
   void FocusIn(ui::TextInputType input_type) {
     ui::IMEEngineHandlerInterface::InputContext input_context(
         input_type, ui::TEXT_INPUT_MODE_DEFAULT, ui::TEXT_INPUT_FLAG_NONE);
     engine_->FocusIn(input_context);
     ui::IMEBridge::Get()->SetCurrentInputContext(input_context);
@@ skipping 82 matching lines @@
   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(kTestImeComponentId);
-  std::vector<ui::IMEEngineHandlerInterface::SegmentInfo> segments;
+  std::vector<InputMethodEngineBase::SegmentInfo> segments;
   int context = engine_->GetCotextIdForTesting();
   std::string error;
   base::HistogramTester histograms;
   engine_->SetComposition(context, "test", 0, 0, 0, segments, NULL);
   engine_->CommitText(context, "input", &error);
   engine_->SetComposition(context, "test", 0, 0, 0, segments, NULL);
   engine_->CommitText(context,
                       "\xE5\x85\xA5\xE5\x8A\x9B",  // 2 UTF-8 characters
                       &error);
   engine_->SetComposition(context, "test", 0, 0, 0, segments, NULL);
   engine_->CommitText(context, "input\xE5\x85\xA5\xE5\x8A\x9B", &error);
   histograms.ExpectTotalCount("InputMethod.CommitLength", 3);
   histograms.ExpectBucketCount("InputMethod.CommitLength", 5, 1);
   histograms.ExpectBucketCount("InputMethod.CommitLength", 2, 1);
   histograms.ExpectBucketCount("InputMethod.CommitLength", 7, 1);
 }
 
 TEST_F(InputMethodEngineTest, TestCompositionBoundsChanged) {
   CreateEngine(true);
   // Enable/disable with focus.
   std::vector<gfx::Rect> rects;
   rects.push_back(gfx::Rect());
   engine_->SetCompositionBounds(rects);
   EXPECT_EQ(ONCOMPOSITIONBOUNDSCHANGED, observer_->GetCallsBitmapAndReset());
 }
 
 }  // namespace input_method
 }  // namespace chromeos