Fixes unittests with --enable-text-input-focus-manager flag enabled.

ui/base/ime/input_method_base_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/input_method_base.h"
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/scoped_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/input_method_observer.h"
+#include "ui/base/ime/text_input_focus_manager.h"
+#include "ui/base/ui_base_switches_util.h"
 #include "ui/events/event.h"
 
 namespace ui {
 namespace {
 
 class ClientChangeVerifier {
  public:
   ClientChangeVerifier()
      : previous_client_(NULL),
        next_client_(NULL),
@@ skipping 20 matching lines @@
     previous_client_ = previous_client;
     next_client_ = next_client;
     call_expected_ = true;
     on_will_change_focused_client_called_ = false;
     on_did_change_focused_client_called_ = false;
     on_text_input_state_changed_ = false;
   }
 
   // Verifies the result satisfies the expectation or not.
   void Verify() {
-    EXPECT_EQ(call_expected_, on_will_change_focused_client_called_);
-    EXPECT_EQ(call_expected_, on_did_change_focused_client_called_);
-    EXPECT_EQ(call_expected_, on_text_input_state_changed_);
+    if (switches::IsTextInputFocusManagerEnabled()) {
+      EXPECT_FALSE(on_will_change_focused_client_called_);
+      EXPECT_FALSE(on_did_change_focused_client_called_);
+      EXPECT_FALSE(on_text_input_state_changed_);
+    } else {
+      EXPECT_EQ(call_expected_, on_will_change_focused_client_called_);
+      EXPECT_EQ(call_expected_, on_did_change_focused_client_called_);
+      EXPECT_EQ(call_expected_, on_text_input_state_changed_);
+    }
   }
 
   void OnWillChangeFocusedClient(TextInputClient* focused_before,
                                  TextInputClient* focused) {
     EXPECT_TRUE(call_expected_);
 
     // Check arguments
     EXPECT_EQ(previous_client_, focused_before);
     EXPECT_EQ(next_client_, focused);
 
@@ skipping 170 matching lines @@
 
  private:
   int shown_event_count_;
   int updated_event_count_;
   int hidden_event_count_;
 };
 
 typedef ScopedObserver<InputMethod, InputMethodObserver>
     InputMethodScopedObserver;
 
+void SetFocusedTextInputClient(InputMethod* input_method,
+                               TextInputClient* text_input_client) {
+  if (switches::IsTextInputFocusManagerEnabled()) {
+    TextInputFocusManager::GetInstance()->FocusTextInputClient(
+        text_input_client);
+  } else {
+    input_method->SetFocusedTextInputClient(text_input_client);
+  }
+}
+
 TEST_F(InputMethodBaseTest, SetFocusedTextInputClient) {
   DummyTextInputClient text_input_client_1st;
   DummyTextInputClient text_input_client_2nd;
 
   ClientChangeVerifier verifier;
   MockInputMethodBase input_method(&verifier);
   MockInputMethodObserver input_method_observer(&verifier);
   InputMethodScopedObserver scoped_observer(&input_method_observer);
   scoped_observer.Add(&input_method);
 
   // Assume that the top-level-widget gains focus.
   input_method.OnFocus();
 
   {
     SCOPED_TRACE("Focus from NULL to 1st TextInputClient");
 
     ASSERT_EQ(NULL, input_method.GetTextInputClient());
     verifier.ExpectClientChange(NULL, &text_input_client_1st);
-    input_method.SetFocusedTextInputClient(&text_input_client_1st);
+    SetFocusedTextInputClient(&input_method, &text_input_client_1st);
     EXPECT_EQ(&text_input_client_1st, input_method.GetTextInputClient());
     verifier.Verify();
   }
 
   {
     SCOPED_TRACE("Redundant focus events must be ignored");
     verifier.ExpectClientDoesNotChange();
-    input_method.SetFocusedTextInputClient(&text_input_client_1st);
+    SetFocusedTextInputClient(&input_method, &text_input_client_1st);
     verifier.Verify();
   }
 
   {
     SCOPED_TRACE("Focus from 1st to 2nd TextInputClient");
 
     ASSERT_EQ(&text_input_client_1st, input_method.GetTextInputClient());
     verifier.ExpectClientChange(&text_input_client_1st,
                                 &text_input_client_2nd);
-    input_method.SetFocusedTextInputClient(&text_input_client_2nd);
+    SetFocusedTextInputClient(&input_method, &text_input_client_2nd);
     EXPECT_EQ(&text_input_client_2nd, input_method.GetTextInputClient());
     verifier.Verify();
   }
 
   {
     SCOPED_TRACE("Focus from 2nd TextInputClient to NULL");
 
     ASSERT_EQ(&text_input_client_2nd, input_method.GetTextInputClient());
     verifier.ExpectClientChange(&text_input_client_2nd, NULL);
-    input_method.SetFocusedTextInputClient(NULL);
+    SetFocusedTextInputClient(&input_method, NULL);
     EXPECT_EQ(NULL, input_method.GetTextInputClient());
     verifier.Verify();
   }
 
   {
     SCOPED_TRACE("Redundant focus events must be ignored");
     verifier.ExpectClientDoesNotChange();
-    input_method.SetFocusedTextInputClient(NULL);
+    SetFocusedTextInputClient(&input_method, NULL);
     verifier.Verify();
   }
 }
 
 TEST_F(InputMethodBaseTest, DetachTextInputClient) {
+  // DetachTextInputClient is not supported when IsTextInputFocusManagerEnabled.
+  if (switches::IsTextInputFocusManagerEnabled())
+    return;
+
   DummyTextInputClient text_input_client;
   DummyTextInputClient text_input_client_the_other;
 
   ClientChangeVerifier verifier;
   MockInputMethodBase input_method(&verifier);
   MockInputMethodObserver input_method_observer(&verifier);
   InputMethodScopedObserver scoped_observer(&input_method_observer);
   scoped_observer.Add(&input_method);
 
   // Assume that the top-level-widget gains focus.
@@ skipping 31 matching lines @@
 
 TEST_F(InputMethodBaseTest, CandidateWindowEvents) {
   MockTextInputClient text_input_client;
 
   {
     ClientChangeVerifier verifier;
     MockInputMethodBase input_method_base(&verifier);
     input_method_base.OnFocus();
 
     verifier.ExpectClientChange(NULL, &text_input_client);
-    input_method_base.SetFocusedTextInputClient(&text_input_client);
+    SetFocusedTextInputClient(&input_method_base, &text_input_client);
 
     EXPECT_EQ(0, text_input_client.shown_event_count());
     EXPECT_EQ(0, text_input_client.updated_event_count());
     EXPECT_EQ(0, text_input_client.hidden_event_count());
 
     input_method_base.OnCandidateWindowShown();
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(1, text_input_client.shown_event_count());
     EXPECT_EQ(0, text_input_client.updated_event_count());
@@ skipping 19 matching lines @@
   // If InputMethod is deleted immediately after an event happens, but before
   // its callback is invoked, the callback will be cancelled.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, text_input_client.shown_event_count());
   EXPECT_EQ(1, text_input_client.updated_event_count());
   EXPECT_EQ(1, text_input_client.hidden_event_count());
 }
 
 }  // namespace
 }  // namespace ui