Add OnCompositionChanged and OnTextCommitted to RemoteInputMethodPrivateWin

ui/base/ime/remote_input_method_win_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/remote_input_method_win.h"
 
 #include <InputScope.h>
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_delegate.h"
 #include "ui/base/ime/input_method_observer.h"
 #include "ui/base/ime/remote_input_method_delegate_win.h"
 #include "ui/events/event.h"
 
 namespace ui {
 namespace {
 
 class MockTextInputClient : public DummyTextInputClient {
  public:
   MockTextInputClient()
       : text_input_type_(TEXT_INPUT_TYPE_NONE),
-        text_input_mode_(TEXT_INPUT_MODE_DEFAULT) {
+        text_input_mode_(TEXT_INPUT_MODE_DEFAULT),
+        call_count_set_composition_text_(0),
+        call_count_insert_char_(0),
+        call_count_insert_text_(0) {
   }
 
+  size_t call_count_set_composition_text() const {
+    return call_count_set_composition_text_;
+  }
   const base::string16& inserted_text() const {
     return inserted_text_;
   }
+  size_t call_count_insert_char() const {
+    return call_count_insert_char_;
+  }
+  size_t call_count_insert_text() const {
+    return call_count_insert_text_;
+  }
   void Reset() {
-    inserted_text_.clear();
     text_input_type_ = TEXT_INPUT_TYPE_NONE;
     text_input_mode_ = TEXT_INPUT_MODE_DEFAULT;
+    call_count_set_composition_text_ = 0;
+    inserted_text_.clear();
+    call_count_insert_char_ = 0;
+    call_count_insert_text_ = 0;
     caret_bounds_ = gfx::Rect();
     composition_character_bounds_.clear();
   }
   void set_text_input_type(ui::TextInputType type) {
     text_input_type_ = type;
   }
   void set_text_input_mode(ui::TextInputMode mode) {
     text_input_mode_ = mode;
   }
   void set_caret_bounds(const gfx::Rect& caret_bounds) {
     caret_bounds_ = caret_bounds;
   }
   void set_composition_character_bounds(
       const std::vector<gfx::Rect>& composition_character_bounds) {
     composition_character_bounds_ = composition_character_bounds;
   }
 
  private:
+  // Overriden from DummyTextInputClient.
+  virtual void SetCompositionText(
+      const ui::CompositionText& composition) OVERRIDE {
+    ++call_count_set_composition_text_;
+  }
   virtual void InsertChar(char16 ch, int flags) OVERRIDE{
     inserted_text_.append(1, ch);
+    ++call_count_insert_char_;
   }
   virtual void InsertText(const string16& text) OVERRIDE{
-    EXPECT_TRUE(false) << "RemoteInputMethodWin does not use this method";
+    inserted_text_.append(text);
+    ++call_count_insert_text_;
   }
   virtual ui::TextInputType GetTextInputType() const OVERRIDE {
     return text_input_type_;
   }
   virtual ui::TextInputMode GetTextInputMode() const OVERRIDE {
     return text_input_mode_;
   }
   virtual gfx::Rect GetCaretBounds() const {
     return caret_bounds_;
   }
   virtual bool GetCompositionCharacterBounds(uint32 index,
                                              gfx::Rect* rect) const OVERRIDE {
     if (!rect || composition_character_bounds_.size() <= index)
       return false;
     *rect = composition_character_bounds_[index];
     return true;
   }
   virtual bool HasCompositionText() const OVERRIDE {
     return !composition_character_bounds_.empty();
   }
 
   ui::TextInputType text_input_type_;
   ui::TextInputMode text_input_mode_;
   gfx::Rect caret_bounds_;
   std::vector<gfx::Rect> composition_character_bounds_;
   base::string16 inserted_text_;
+  size_t call_count_set_composition_text_;
+  size_t call_count_insert_char_;
+  size_t call_count_insert_text_;
   DISALLOW_COPY_AND_ASSIGN(MockTextInputClient);
 };
 
 class MockInputMethodDelegate : public internal::InputMethodDelegate {
  public:
   MockInputMethodDelegate() {}
 
   const std::vector<ui::KeyboardCode>& fabricated_key_events() const {
     return fabricated_key_events_;
   }
@@ skipping 528 matching lines @@
 
   // TextInputClient is now focused here.
 
   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
   EXPECT_EQ(L"A", mock_text_input_client.inserted_text());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 }
 
+TEST(RemoteInputMethodWinTest, OnCompositionChanged) {
+  MockInputMethodDelegate delegate_;
+  MockTextInputClient mock_text_input_client;
+  scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
+
+  RemoteInputMethodPrivateWin* private_ptr =
+      RemoteInputMethodPrivateWin::Get(input_method.get());
+  ASSERT_TRUE(private_ptr != NULL);
+  MockRemoteInputMethodDelegateWin mock_remote_delegate;
+  private_ptr->SetRemoteDelegate(&mock_remote_delegate);
+
+  CompositionText composition_text;
+
+  // TextInputClient is not focused yet here.
+
+  private_ptr->OnCompositionChanged(composition_text);
+  EXPECT_EQ(0, mock_text_input_client.call_count_set_composition_text());
+  delegate_.Reset();
+  mock_text_input_client.Reset();
+
+  input_method->SetFocusedTextInputClient(&mock_text_input_client);
+
+  // TextInputClient is now focused here.
+
+  private_ptr->OnCompositionChanged(composition_text);
+  EXPECT_EQ(1, mock_text_input_client.call_count_set_composition_text());
+  delegate_.Reset();
+  mock_text_input_client.Reset();
+}
+
+TEST(RemoteInputMethodWinTest, OnTextCommitted) {
+  MockInputMethodDelegate delegate_;
+  MockTextInputClient mock_text_input_client;
+  scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
+
+  RemoteInputMethodPrivateWin* private_ptr =
+      RemoteInputMethodPrivateWin::Get(input_method.get());
+  ASSERT_TRUE(private_ptr != NULL);
+  MockRemoteInputMethodDelegateWin mock_remote_delegate;
+  private_ptr->SetRemoteDelegate(&mock_remote_delegate);
+
+  base::string16 committed_text = L"Hello";
+
+  // TextInputClient is not focused yet here.
+
+  mock_text_input_client.set_text_input_type(TEXT_INPUT_TYPE_TEXT);
+  private_ptr->OnTextCommitted(committed_text);
+  EXPECT_EQ(0, mock_text_input_client.call_count_insert_char());
+  EXPECT_EQ(0, mock_text_input_client.call_count_insert_text());
+  EXPECT_EQ(L"", mock_text_input_client.inserted_text());
+  delegate_.Reset();
+  mock_text_input_client.Reset();
+
+  input_method->SetFocusedTextInputClient(&mock_text_input_client);
+
+  // TextInputClient is now focused here.
+
+  mock_text_input_client.set_text_input_type(TEXT_INPUT_TYPE_TEXT);
+  private_ptr->OnTextCommitted(committed_text);
+  EXPECT_EQ(0, mock_text_input_client.call_count_insert_char());
+  EXPECT_EQ(1, mock_text_input_client.call_count_insert_text());
+  EXPECT_EQ(committed_text, mock_text_input_client.inserted_text());
+  delegate_.Reset();
+  mock_text_input_client.Reset();
+
+  // When TextInputType is TEXT_INPUT_TYPE_NONE, TextInputClient::InsertText
+  // should not be used.
+  mock_text_input_client.set_text_input_type(TEXT_INPUT_TYPE_NONE);
+  private_ptr->OnTextCommitted(committed_text);
+  EXPECT_EQ(committed_text.size(),
+            mock_text_input_client.call_count_insert_char());
+  EXPECT_EQ(0, mock_text_input_client.call_count_insert_text());
+  EXPECT_EQ(committed_text, mock_text_input_client.inserted_text());
+  delegate_.Reset();
+  mock_text_input_client.Reset();
+}
+
 TEST(RemoteInputMethodWinTest, OnTextInputStateChanged_Observer) {
   DummyTextInputClient text_input_client;
   DummyTextInputClient text_input_client_the_other;
 
   MockInputMethodObserver input_method_observer;
   MockInputMethodDelegate delegate_;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
   InputMethodScopedObserver scoped_observer(&input_method_observer);
   scoped_observer.Add(input_method.get());
 
@@ skipping 75 matching lines @@
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
   input_method->AddObserver(&input_method_observer);
 
   EXPECT_EQ(0u, input_method_observer.on_input_method_destroyed_changed());
   input_method.reset();
   EXPECT_EQ(1u, input_method_observer.on_input_method_destroyed_changed());
 }
 
 }  // namespace
 }  // namespace ui