Remove PendingCreateICRequest.

ui/base/ime/input_method_ibus_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 <cstring>
 
 #include "base/i18n/char_iterator.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/ibus/ibus_text.h"
 #include "chromeos/dbus/ibus/mock_ibus_client.h"
 #include "chromeos/dbus/ibus/mock_ibus_input_context_client.h"
 #include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ime/input_method_delegate.h"
 #include "ui/base/ime/input_method_ibus.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/gfx/rect.h"
 
 namespace ui {
 namespace {
+const int kCreateInputContextMaxTrialCount = 10;
 
 uint32 GetOffsetInUTF16(const std::string& utf8_string, uint32 utf8_offset) {
   string16 utf16_string = UTF8ToUTF16(utf8_string);
   DCHECK_LT(utf8_offset, utf16_string.size());
   base::i18n::UTF16CharIterator char_iterator(&utf16_string);
   for (size_t i = 0; i < utf8_offset; ++i)
     char_iterator.Advance();
   return char_iterator.array_pos();
 }
 
@@ skipping 18 matching lines @@
 
   void Run(const std::string& client_name,
            const chromeos::IBusClient::CreateInputContextCallback& callback,
            const chromeos::IBusClient::ErrorCallback& error_callback) {
     EXPECT_EQ("chrome", client_name);
     callback.Run(object_path_);
   }
 
  private:
   dbus::ObjectPath object_path_;
+
+  DISALLOW_COPY_AND_ASSIGN(CreateInputContextSuccessHandler);
 };
 
 class CreateInputContextFailHandler {
  public:
+  CreateInputContextFailHandler() {}
   void Run(const std::string& client_name,
            const chromeos::IBusClient::CreateInputContextCallback& callback,
            const chromeos::IBusClient::ErrorCallback& error_callback) {
     error_callback.Run();
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CreateInputContextFailHandler);
 };
 
 class CreateInputContextNoResponseHandler {
  public:
+  CreateInputContextNoResponseHandler() {}
   void Run(const std::string& client_name,
            const chromeos::IBusClient::CreateInputContextCallback& callback,
            const chromeos::IBusClient::ErrorCallback& error_callback) {
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CreateInputContextNoResponseHandler);
 };
 
-class CreateInputContextDelayFailHandler {
+class CreateInputContextDelayHandler {
  public:
-  ~CreateInputContextDelayFailHandler() {
-    error_callback_.Run();
+  explicit CreateInputContextDelayHandler(const dbus::ObjectPath& object_path)
+    : object_path_(object_path) {
   }
 
   void Run(const std::string& client_name,
            const chromeos::IBusClient::CreateInputContextCallback& callback,
            const chromeos::IBusClient::ErrorCallback& error_callback) {
+    callback_ = callback;
     error_callback_ = error_callback;
   }
 
+  void RunCallback(bool success) {
+    if (success)
+      callback_.Run(object_path_);
+    else
+      error_callback_.Run();
+  }
+
+ private:
+  dbus::ObjectPath object_path_;
+  chromeos::IBusClient::CreateInputContextCallback callback_;
   chromeos::IBusClient::ErrorCallback error_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(CreateInputContextDelayHandler);
 };
 
 class InputMethodIBusTest : public internal::InputMethodDelegate,
                             public testing::Test,
                             public TextInputClient {
  public:
   InputMethodIBusTest() {
     ResetFlags();
   }
 
@@ skipping 143 matching lines @@
 
   // Variables that will be returned from the ui::TextInputClient functions.
   TextInputType input_type_;
   bool can_compose_inline_;
   gfx::Rect caret_bounds_;
 
   // Variables for mock dbus connections.
   chromeos::MockDBusThreadManagerWithoutGMock* mock_dbus_thread_manager_;
   chromeos::MockIBusClient* mock_ibus_client_;
   chromeos::MockIBusInputContextClient* mock_ibus_input_context_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(InputMethodIBusTest);
 };
 
 // Tests public APIs in ui::InputMethod first.
 
 TEST_F(InputMethodIBusTest, GetInputLocale) {
   // ui::InputMethodIBus does not support the API.
   ime_->Init(true);
   EXPECT_EQ("", ime_->GetInputLocale());
 }
 
@@ skipping 85 matching lines @@
 TEST_F(InputMethodIBusTest, InitiallyConnected) {
   SetCreateContextSuccessHandler();
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->Init(true);
   // An input context should be created immediately since is_connected_ is true.
   EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
   EXPECT_EQ(1, mock_ibus_input_context_client_->set_capabilities_call_count());
   // However, since the current text input type is 'NONE' (the default), FocusIn
   // shouldn't be called.
   EXPECT_EQ(0, mock_ibus_input_context_client_->focus_in_call_count());
+  EXPECT_TRUE(mock_ibus_input_context_client_->IsObjectProxyReady());
 }
 
 // Create ui::InputMethodIBus, then start ibus-daemon.
 TEST_F(InputMethodIBusTest, InitiallyDisconnected) {
   SetCreateContextSuccessHandler();
   ime_->Init(true);
   // A context shouldn't be created since the daemon is not running.
   EXPECT_EQ(0, mock_ibus_client_->create_input_context_call_count());
   // Start the daemon.
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->OnConnected();
   // A context should be created upon the signal delivery.
   EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
   EXPECT_EQ(1, mock_ibus_input_context_client_->set_capabilities_call_count());
   EXPECT_EQ(0, mock_ibus_input_context_client_->focus_in_call_count());
+  EXPECT_TRUE(mock_ibus_input_context_client_->IsObjectProxyReady());
 }
 
 // Confirm that ui::InputMethodIBus does not crash on "disconnected" signal
 // delivery.
 TEST_F(InputMethodIBusTest, Disconnect) {
   SetCreateContextSuccessHandler();
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->Init(true);
   EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
   // Currently we can't shutdown IBusBus connection except in
   // DBusThreadManager's shutting down. So set ibus_bus_ as NULL to emulate
   // dynamical shutting down.
   mock_dbus_thread_manager_->set_ibus_bus(NULL);
   ime_->OnDisconnected();
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
 }
 
 // Confirm that ui::InputMethodIBus re-creates an input context when ibus-daemon
 // restarts.
 TEST_F(InputMethodIBusTest, DisconnectThenReconnect) {
   SetCreateContextSuccessHandler();
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->Init(true);
   EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
   EXPECT_EQ(1, mock_ibus_input_context_client_->set_capabilities_call_count());
   EXPECT_EQ(0,
             mock_ibus_input_context_client_->reset_object_proxy_call_caount());
   mock_dbus_thread_manager_->set_ibus_bus(NULL);
   ime_->OnDisconnected();
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->OnConnected();
   // Check if the old context is deleted.
   EXPECT_EQ(1,
             mock_ibus_input_context_client_->reset_object_proxy_call_caount());
   // Check if a new context is created.
   EXPECT_EQ(2, mock_ibus_client_->create_input_context_call_count());
   EXPECT_EQ(2, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_TRUE(mock_ibus_input_context_client_->IsObjectProxyReady());
 }
 
 // Confirm that ui::InputMethodIBus does not crash even if NULL context is
 // passed.
 // TODO(yusukes): Currently, ui::InputMethodIBus does not try to create ic once
 // it fails (unless ibus sends the "connected" signal to Chrome again). It might
 // be better to add some retry logic. Will revisit later.
 TEST_F(InputMethodIBusTest, CreateContextFail) {
   CreateInputContextFailHandler create_input_context_handler;
   mock_ibus_client_->set_create_input_context_handler(base::Bind(
       &CreateInputContextFailHandler::Run,
       base::Unretained(&create_input_context_handler)));
 
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->Init(true);
-  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  // InputMethodIBus tries several times if the CreateInputContext method call
+  // is failed.
+  EXPECT_EQ(kCreateInputContextMaxTrialCount,
+            mock_ibus_client_->create_input_context_call_count());
   // |set_capabilities_call_count()| should be zero since a context is not
   // created yet.
   EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
 }
 
 // Confirm that ui::InputMethodIBus does not crash even if ibus-daemon does not
 // respond.
 TEST_F(InputMethodIBusTest, CreateContextNoResp) {
   CreateInputContextNoResponseHandler create_input_context_handler;
   mock_ibus_client_->set_create_input_context_handler(base::Bind(
       &CreateInputContextNoResponseHandler::Run,
       base::Unretained(&create_input_context_handler)));
 
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->Init(true);
   EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
   EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
 }
 
 // Confirm that ui::InputMethodIBus does not crash even if ibus-daemon responds
-// after ui::InputMethodIBus is deleted. See comments in ~MockIBusClient() as
-// well.
-TEST_F(InputMethodIBusTest, CreateContextDelayed) {
-  CreateInputContextDelayFailHandler create_input_context_handler;
+// after ui::InputMethodIBus is deleted.
+TEST_F(InputMethodIBusTest, CreateContextFailDelayed) {
+  CreateInputContextDelayHandler create_input_context_handler(
+      dbus::ObjectPath("Sample object path"));
   mock_ibus_client_->set_create_input_context_handler(base::Bind(
-      &CreateInputContextDelayFailHandler::Run,
+      &CreateInputContextDelayHandler::Run,
       base::Unretained(&create_input_context_handler)));
 
   chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
   ime_->Init(true);
   EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
   EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
-  // After this line, the destructor for |ime_| will run first. Then, the
-  // destructor for the handler will run. In the latter function, a new input
-  // context will be created and passed to InitOrAbandonInputContext().
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  ime_->SetFocusedTextInputClient(NULL);
+  ime_.reset();
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  create_input_context_handler.RunCallback(false);
+  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+}
+
+// Confirm that ui::InputMethodIBus does not crash even if ibus-daemon responds
+// after ui::InputMethodIBus is deleted.
+TEST_F(InputMethodIBusTest, CreateContextSuccessDelayed) {
+  CreateInputContextDelayHandler create_input_context_handler(
+      dbus::ObjectPath("Sample object path"));
+  mock_ibus_client_->set_create_input_context_handler(base::Bind(
+      &CreateInputContextDelayHandler::Run,
+      base::Unretained(&create_input_context_handler)));
+
+  chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
+  ime_->Init(true);
+  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  ime_->SetFocusedTextInputClient(NULL);
+  ime_.reset();
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  create_input_context_handler.RunCallback(true);
+  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+}
+
+// Confirm that ui::InputMethodIBus does not crash even if ibus-daemon responds
+// after disconnected from ibus-daemon.
+TEST_F(InputMethodIBusTest, CreateContextSuccessDelayedAfterDisconnection) {
+  CreateInputContextDelayHandler create_input_context_handler(
+      dbus::ObjectPath("Sample object path"));
+  mock_ibus_client_->set_create_input_context_handler(base::Bind(
+      &CreateInputContextDelayHandler::Run,
+      base::Unretained(&create_input_context_handler)));
+
+  chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
+  ime_->Init(true);
+  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  ime_->OnDisconnected();
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  create_input_context_handler.RunCallback(true);
+  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+}
+
+// Confirm that ui::InputMethodIBus does not crash even if ibus-daemon responds
+// after disconnected from ibus-daemon.
+TEST_F(InputMethodIBusTest, CreateContextFailDelayedAfterDisconnection) {
+  CreateInputContextDelayHandler create_input_context_handler(
+      dbus::ObjectPath("Sample object path"));
+  mock_ibus_client_->set_create_input_context_handler(base::Bind(
+      &CreateInputContextDelayHandler::Run,
+      base::Unretained(&create_input_context_handler)));
+
+  chromeos::DBusThreadManager::Get()->InitIBusBus("dummy address");
+  ime_->Init(true);
+  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  ime_->OnDisconnected();
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
+
+  create_input_context_handler.RunCallback(false);
+  EXPECT_EQ(1, mock_ibus_client_->create_input_context_call_count());
+  EXPECT_EQ(0, mock_ibus_input_context_client_->set_capabilities_call_count());
+  EXPECT_FALSE(mock_ibus_input_context_client_->IsObjectProxyReady());
 }
 
 // Confirm that IBusClient::FocusIn is called on "connected" if input_type_ is
 // TEXT.
 TEST_F(InputMethodIBusTest, FocusIn_Text) {
   SetCreateContextSuccessHandler();
   ime_->Init(true);
   // A context shouldn't be created since the daemon is not running.
   EXPECT_EQ(0, mock_ibus_client_->create_input_context_call_count());
   EXPECT_EQ(0U, on_input_method_changed_call_count_);
@@ skipping 298 matching lines @@
             composition_text.underlines[0].start_offset);
   EXPECT_EQ(GetOffsetInUTF16(kSampleText, selection.end_index),
             composition_text.underlines[0].end_offset);
   EXPECT_EQ(SK_ColorBLACK, composition_text.underlines[0].color);
   EXPECT_TRUE(composition_text.underlines[0].thick);
 }
 
 // TODO(nona): Write more tests, especially for key event functions.
 
 }  // namespace ui