GetActiveUserProfile() should not be called before profile is initialized.

chrome/browser/chromeos/input_method/input_method_manager_impl_unittest.cc

 // Copyright (c) 2012 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_manager_impl.h"
 
 #include <algorithm>
 
 #include "ash/ime/input_method_menu_item.h"
 #include "ash/ime/input_method_menu_manager.h"
@@ skipping 40 matching lines @@
     if (descriptors[i].id() == target.id())
       return true;
   }
   return false;
 }
 
 std::string ImeIdFromEngineId(const std::string& id) {
   return extension_ime_util::GetInputMethodIDByEngineID(id);
 }
 
+class TestObserver : public InputMethodManager::Observer,
+                     public ash::ime::InputMethodMenuManager::Observer {
+ public:
+  TestObserver()
+      : input_method_changed_count_(0),
+        input_method_menu_item_changed_count_(0),
+        last_show_message_(false) {
+  }
+  virtual ~TestObserver() {}
+
+  virtual void InputMethodChanged(InputMethodManager* manager,
+                                  bool show_message) OVERRIDE {
+    ++input_method_changed_count_;
+    last_show_message_ = show_message;
+  }
+  virtual void InputMethodMenuItemChanged(
+      ash::ime::InputMethodMenuManager* manager) OVERRIDE {
+    ++input_method_menu_item_changed_count_;
+  }
+
+  int input_method_changed_count_;
+  int input_method_menu_item_changed_count_;
+  bool last_show_message_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestObserver);
+};
+
+class TestCandidateWindowObserver
+    : public InputMethodManager::CandidateWindowObserver {
+ public:
+  TestCandidateWindowObserver()
+      : candidate_window_opened_count_(0),
+        candidate_window_closed_count_(0) {
+  }
+
+  virtual ~TestCandidateWindowObserver() {}
+
+  virtual void CandidateWindowOpened(InputMethodManager* manager) OVERRIDE {
+    ++candidate_window_opened_count_;
+  }
+  virtual void CandidateWindowClosed(InputMethodManager* manager) OVERRIDE {
+    ++candidate_window_closed_count_;
+  }
+
+  int candidate_window_opened_count_;
+  int candidate_window_closed_count_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestCandidateWindowObserver);
+};
+}  // namespace
+
 class InputMethodManagerImplTest :  public BrowserWithTestWindowTest {
  public:
   InputMethodManagerImplTest()
       : delegate_(NULL),
         candidate_window_controller_(NULL),
         keyboard_(NULL) {
   }
   virtual ~InputMethodManagerImplTest() {}
 
   virtual void SetUp() OVERRIDE {
@@ skipping 30 matching lines @@
 
     delegate_ = NULL;
     candidate_window_controller_ = NULL;
     keyboard_ = NULL;
     manager_.reset();
 
     profile_manager_.reset();
   }
 
  protected:
+  Profile* GetProfile() { return manager_->GetProfile(); }
   // Helper function to initialize component extension stuff for testing.
   void InitComponentExtension() {
     mock_delegate_ = new MockComponentExtIMEManagerDelegate();
     mock_delegate_->set_ime_list(ime_list_);
     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate(mock_delegate_);
 
     // Note, for production, these SetEngineHandler are called when
     // IMEEngineHandlerInterface is initialized via
     // InitializeComponentextension.
-    manager_->AddInputMethodExtension(ImeIdFromEngineId(kNaclMozcUsId),
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kNaclMozcUsId),
                                       mock_engine_handler_.get());
-    manager_->AddInputMethodExtension(ImeIdFromEngineId(kNaclMozcJpId),
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kNaclMozcJpId),
                                       mock_engine_handler_.get());
-    manager_->AddInputMethodExtension(ImeIdFromEngineId(kExt2Engine1Id),
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kExt2Engine1Id),
                                       mock_engine_handler_.get());
-    manager_->AddInputMethodExtension(ImeIdFromEngineId(kExt2Engine2Id),
+    manager_->AddInputMethodExtension(GetProfile(),
+                                      ImeIdFromEngineId(kExt2Engine2Id),
                                       mock_engine_handler_.get());
     manager_->InitializeComponentExtensionForTesting(delegate.Pass());
   }
 
   void InitImeList() {
     ime_list_.clear();
 
     ComponentExtensionIME ext_xkb;
     ext_xkb.id = extension_ime_util::kXkbExtensionId;
     ext_xkb.description = "ext_xkb_description";
@@ skipping 125 matching lines @@
   scoped_ptr<MockInputMethodEngine> mock_engine_handler_;
   FakeImeKeyboard* keyboard_;
   MockComponentExtIMEManagerDelegate* mock_delegate_;
   std::vector<ComponentExtensionIME> ime_list_;
   ash::ime::InputMethodMenuManager* menu_manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImplTest);
 };
 
-class TestObserver : public InputMethodManager::Observer,
-                     public ash::ime::InputMethodMenuManager::Observer{
- public:
-  TestObserver()
-      : input_method_changed_count_(0),
-        input_method_menu_item_changed_count_(0),
-        last_show_message_(false) {
-  }
-  virtual ~TestObserver() {}
-
-  virtual void InputMethodChanged(InputMethodManager* manager,
-                                  bool show_message) OVERRIDE {
-    ++input_method_changed_count_;
-    last_show_message_ = show_message;
-  }
-  virtual void InputMethodMenuItemChanged(
-      ash::ime::InputMethodMenuManager* manager) OVERRIDE {
-    ++input_method_menu_item_changed_count_;
-  }
-
-  int input_method_changed_count_;
-  int input_method_menu_item_changed_count_;
-  bool last_show_message_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestObserver);
-};
-
-class TestCandidateWindowObserver
-    : public InputMethodManager::CandidateWindowObserver {
- public:
-  TestCandidateWindowObserver()
-      : candidate_window_opened_count_(0),
-        candidate_window_closed_count_(0) {
-  }
-  virtual ~TestCandidateWindowObserver() {}
-
-  virtual void CandidateWindowOpened(InputMethodManager* manager) OVERRIDE {
-    ++candidate_window_opened_count_;
-  }
-  virtual void CandidateWindowClosed(InputMethodManager* manager) OVERRIDE {
-    ++candidate_window_closed_count_;
-  }
-
-  int candidate_window_opened_count_;
-  int candidate_window_closed_count_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestCandidateWindowObserver);
-};
-}  // namespace
-
 TEST_F(InputMethodManagerImplTest, TestGetImeKeyboard) {
   EXPECT_TRUE(manager_->GetImeKeyboard());
   EXPECT_EQ(keyboard_, manager_->GetImeKeyboard());
 }
 
 TEST_F(InputMethodManagerImplTest, TestCandidateWindowObserver) {
   TestCandidateWindowObserver observer;
   candidate_window_controller_->NotifyCandidateWindowOpened();  // nop
   candidate_window_controller_->NotifyCandidateWindowClosed();  // nop
   manager_->AddCandidateWindowObserver(&observer);
@@ skipping 788 matching lines @@
       extension_ime_util::GetInputMethodID("deadbeef", "engine_id");
   const InputMethodDescriptor descriptor1(ext1_id,
                                           "deadbeef input method",
                                           "DB",
                                           layouts,
                                           languages,
                                           false,  // is_login_keyboard
                                           GURL(),
                                           GURL());
   MockInputMethodEngine engine(descriptor1);
-  manager_->AddInputMethodExtension(ext1_id, &engine);
+  manager_->AddInputMethodExtension(GetProfile(), ext1_id, &engine);
 
   // Extension IMEs are not enabled by default.
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 
   std::vector<std::string> extension_ime_ids;
   extension_ime_ids.push_back(ext1_id);
   manager_->SetEnabledExtensionImes(&extension_ime_ids);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 
   {
     scoped_ptr<InputMethodDescriptors> methods(
         manager_->GetActiveInputMethods());
     ASSERT_EQ(2U, methods->size());
     // Ext IMEs should be at the end of the list.
     EXPECT_EQ(ext1_id, methods->at(1).id());
   }
 
   const std::string ext2_id =
       extension_ime_util::GetInputMethodID("cafebabe", "engine_id");
   const InputMethodDescriptor descriptor2(ext2_id,
                                           "cafebabe input method",
                                           "CB",
                                           layouts,
                                           languages,
                                           false,  // is_login_keyboard
                                           GURL(),
                                           GURL());
   MockInputMethodEngine engine2(descriptor2);
-  manager_->AddInputMethodExtension(ext2_id, &engine2);
+  manager_->AddInputMethodExtension(GetProfile(), ext2_id, &engine2);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 
   extension_ime_ids.push_back(ext2_id);
   manager_->SetEnabledExtensionImes(&extension_ime_ids);
   EXPECT_EQ(3U, manager_->GetNumActiveInputMethods());
   {
     scoped_ptr<InputMethodDescriptors> methods(
         manager_->GetActiveInputMethods());
     ASSERT_EQ(3U, methods->size());
     // Ext IMEs should be at the end of the list.
     EXPECT_EQ(ext1_id, methods->at(1).id());
     EXPECT_EQ(ext2_id, methods->at(2).id());
   }
 
   // Remove them.
-  manager_->RemoveInputMethodExtension(ext1_id);
+  manager_->RemoveInputMethodExtension(GetProfile(), ext1_id);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
-  manager_->RemoveInputMethodExtension(ext2_id);
+  manager_->RemoveInputMethodExtension(GetProfile(), ext2_id);
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
 }
 
 TEST_F(InputMethodManagerImplTest, TestAddExtensionInputThenLockScreen) {
   TestObserver observer;
   InitComponentExtension();
   manager_->AddObserver(&observer);
   manager_->SetState(InputMethodManager::STATE_BROWSER_SCREEN);
   std::vector<std::string> ids;
   ids.push_back(ImeIdFromEngineId("xkb:us::eng"));
@@ skipping 13 matching lines @@
       extension_ime_util::GetInputMethodID("deadbeef", "engine_id");
   const InputMethodDescriptor descriptor(ext_id,
                                          "deadbeef input method",
                                          "DB",
                                          layouts,
                                          languages,
                                          false,  // is_login_keyboard
                                          GURL(),
                                          GURL());
   MockInputMethodEngine engine(descriptor);
-  manager_->AddInputMethodExtension(ext_id, &engine);
+  manager_->AddInputMethodExtension(GetProfile(), ext_id, &engine);
 
   // Extension IME is not enabled by default.
   EXPECT_EQ(1U, manager_->GetNumActiveInputMethods());
   EXPECT_EQ(1, observer.input_method_changed_count_);
 
   std::vector<std::string> extension_ime_ids;
   extension_ime_ids.push_back(ext_id);
   manager_->SetEnabledExtensionImes(&extension_ime_ids);
   EXPECT_EQ(2U, manager_->GetNumActiveInputMethods());
 
@@ skipping 75 matching lines @@
   ASSERT_EQ(4U, input_method_ids.size());
 
   EXPECT_EQ(ImeIdFromEngineId("xkb:us::eng"), input_method_ids[0]);
   EXPECT_EQ(ImeIdFromEngineId("xkb:fr::fra"), input_method_ids[1]);
   EXPECT_EQ("_comp_ime_asdf_pinyin", input_method_ids[2]);
   EXPECT_EQ(ImeIdFromEngineId("zh-t-i0-pinyin"), input_method_ids[3]);
 }
 
 }  // namespace input_method
 }  // namespace chromeos