Added network components for blimp text input feature

blimp/engine/session/blimp_engine_session.cc

 // Copyright 2015 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 "blimp/engine/session/blimp_engine_session.h"
 
 #include <string>
 
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 14 matching lines @@
 #include "blimp/net/engine_connection_manager.h"
 #include "blimp/net/null_blimp_message_processor.h"
 #include "blimp/net/tcp_engine_transport.h"
 #include "blimp/net/thread_pipe_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
+#include "ui/base/ime/input_method.h"
+#include "ui/base/ime/text_input_client.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/default_activation_client.h"
 #include "ui/wm/core/focus_controller.h"
 
 
 namespace blimp {
 namespace engine {
 namespace {
 
@@ skipping 134 matching lines @@
   DCHECK(engine_config_);
   screen_->UpdateDisplayScaleAndSize(kDefaultScaleFactor,
                                      gfx::Size(kDefaultDisplayWidth,
                                                kDefaultDisplayHeight));
   render_widget_feature_.SetDelegate(kDummyTabId, this);
 }
 
 BlimpEngineSession::~BlimpEngineSession() {
   render_widget_feature_.RemoveDelegate(kDummyTabId);
 
+  window_tree_host_->GetInputMethod()->RemoveObserver(this);
+
   // Ensure that all WebContents are torn down first, since teardown will
   // trigger RenderViewDeleted callbacks to their observers.
   web_contents_.reset();
 
   // Safely delete network components on the IO thread.
   content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
                                      net_components_.release());
 }
 
 void BlimpEngineSession::Initialize() {
   DCHECK(!gfx::Screen::GetScreen());
   gfx::Screen::SetScreenInstance(screen_.get());
 
   context_factory_.reset(new BlimpUiContextFactory());
   aura::Env::GetInstance()->set_context_factory(context_factory_.get());
   window_tree_host_.reset(new BlimpWindowTreeHost());
 
   screen_->set_window_tree_host(window_tree_host_.get());
   window_tree_host_->InitHost();
   window_tree_host_->window()->SetLayoutManager(
       new BlimpLayoutManager(window_tree_host_->window()));
   focus_client_.reset(new wm::FocusController(new FocusRulesImpl));
   aura::client::SetFocusClient(window_tree_host_->window(),
                                focus_client_.get());
   aura::client::SetActivationClient(window_tree_host_->window(),
                                     focus_client_.get());
   capture_client_.reset(
       new aura::client::DefaultCaptureClient(window_tree_host_->window()));
 
+  window_tree_host_->GetInputMethod()->AddObserver(this);
+
   window_tree_host_->SetBounds(gfx::Rect(screen_->GetPrimaryDisplay().size()));
 
   RegisterFeatures();
 
   // Initialize must only be posted after the RegisterFeature calls have
   // completed.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&EngineNetworkComponents::Initialize,
                  base::Unretained(net_components_.get()),
@@ skipping 15 matching lines @@
       thread_pipe_manager_->RegisterFeature(BlimpMessage::NAVIGATION, this);
   render_widget_feature_.set_render_widget_message_sender(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::RENDER_WIDGET,
                                             &render_widget_feature_));
   render_widget_feature_.set_input_message_sender(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::INPUT,
                                             &render_widget_feature_));
   render_widget_feature_.set_compositor_message_sender(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::COMPOSITOR,
                                             &render_widget_feature_));
+  render_widget_feature_.set_ime_message_sender(
+      thread_pipe_manager_->RegisterFeature(BlimpMessage::IME,
+                                            &render_widget_feature_));
 }
 
 bool BlimpEngineSession::CreateWebContents(const int target_tab_id) {
   DVLOG(1) << "Create tab " << target_tab_id;
   // TODO(haibinlu): Support more than one active WebContents (crbug/547231).
   if (web_contents_) {
     DLOG(WARNING) << "Tab " << target_tab_id << " already existed";
     return false;
   }
 
@@ skipping 64 matching lines @@
   render_widget_host->ForwardGestureEvent(*event);
 }
 
 void BlimpEngineSession::OnCompositorMessageReceived(
     content::RenderWidgetHost* render_widget_host,
     const std::vector<uint8_t>& message) {
 
   render_widget_host->HandleCompositorProto(message);
 }
 
+void BlimpEngineSession::OnTextInputTypeChanged(
+    const ui::TextInputClient* client) {}
+
+void BlimpEngineSession::OnFocus() {}
+
+void BlimpEngineSession::OnBlur() {}
+
+void BlimpEngineSession::OnCaretBoundsChanged(
+    const ui::TextInputClient* client) {}
+
+// Called when either:
+//  - the TextInputClient is changed (e.g. by a change of focus)
+//  - the TextInputType of the TextInputClient changes

[David Trainor- moved to gerrit, 2016/03/17 21:53:29]

Add a todo to propagate the new type to the client IMO.

+void BlimpEngineSession::OnTextInputStateChanged(
+    const ui::TextInputClient* client) {
+  ui::TextInputType type =
+      client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
+
+  // Hide IME if text input is out of focus

[David Trainor- moved to gerrit, 2016/03/17 21:53:29]

. at the end.

+  if (type == ui::TEXT_INPUT_TYPE_NONE)

[haibinlu, 2016/03/17 18:59:46]

does ui::TEXT_INPUT_TYPE_NONE mean text input is out of focus?

[shaktisahu, 2016/03/18 19:08:06]

Yes, text input type changes to ui::TEXT_INPUT_TYPE_NONE when the text input
goes out of focus.

[haibinlu, 2016/03/18 19:53:49]

can you add this to the comment?

+    render_widget_feature_.SendHideImeRequest(
+        kDummyTabId,
+        web_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost(),

[Khushal, 2016/03/17 10:02:45]

RenderWidgetHostView can be null. Check that before proceeding further.

+        client);

[Khushal, 2016/03/17 10:02:45]

Do you need to pass the client in this method? Looks like
EngineRenderWidgetFeature doesn't need it.

+}

[haibinlu, 2016/03/17 18:59:46]

what happens to other types? shall you just show the IME?

[shaktisahu, 2016/03/18 19:08:06]

For other text input types, I would receive a call to OnShowImeIFNeeded(), where
I show the IME.
And this is the only place to hide the IME, since I don't receive the calls
OnFocus(), OnBlur() at all.

[haibinlu, 2016/03/18 19:53:49]

Does OnShowImeIFNeeded cover more cases for showing IME than other text input
types here? Also add comment about why other types are not handled here.

[shaktisahu, 2016/03/22 19:44:18]

I would think so, although the api description for OnShowImeIFNeeded is not very
clear. OnShowImeIFNeeded callback seems a more appropriate place to show IME.

+
+void BlimpEngineSession::OnInputMethodDestroyed(
+    const ui::InputMethod* input_method) {}
+
+// Called when a user input should trigger showing the IME.
+void BlimpEngineSession::OnShowImeIfNeeded() {
+  render_widget_feature_.SendShowImeRequest(
+      kDummyTabId,
+      web_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost(),
+      window_tree_host_->GetInputMethod()->GetTextInputClient());

[Khushal, 2016/03/17 10:02:45]

The text input client can also be null. If the expectation is that it shouldn't
be when we get this call, then DCHECK it. Otherwise, just return.

+}
+
 void BlimpEngineSession::ProcessMessage(
     scoped_ptr<BlimpMessage> message,
     const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(message->type() == BlimpMessage::TAB_CONTROL ||
          message->type() == BlimpMessage::NAVIGATION);
 
   net::Error result = net::OK;
   if (message->type() == BlimpMessage::TAB_CONTROL) {
     switch (message->tab_control().type()) {
@@ skipping 156 matching lines @@
 
   aura::Window* parent = window_tree_host_->window();
   aura::Window* content = web_contents_->GetNativeView();
   if (!parent->Contains(content))
     parent->AddChild(content);
   content->Show();
 }
 
 }  // namespace engine
 }  // namespace blimp