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 13 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 135 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());
 
   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
+void BlimpEngineSession::OnTextInputStateChanged(
+    const ui::TextInputClient* client) {
+  if (!web_contents_->GetRenderWidgetHostView())
+    return;
+
+  ui::TextInputType type =
+      client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
+
+  // TODO(shaktisahu): Propagate the new type to the client.
+  // Hide IME, when text input is out of focus, i.e. if the text input type
+  // changes to ui::TEXT_INPUT_TYPE_NONE. For other text input types,
+  // OnShowImeIfNeeded is used instead to send show IME request to client.
+  if (type == ui::TEXT_INPUT_TYPE_NONE)
+    render_widget_feature_.SendHideImeRequest(
+        kDummyTabId,
+        web_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost());
+}
+
+void BlimpEngineSession::OnInputMethodDestroyed(
+    const ui::InputMethod* input_method) {}
+
+// Called when a user input should trigger showing the IME.
+void BlimpEngineSession::OnShowImeIfNeeded() {
+  if (!web_contents_->GetRenderWidgetHostView() ||
+      !window_tree_host_->GetInputMethod()->GetTextInputClient())
+    return;
+
+  render_widget_feature_.SendShowImeRequest(
+      kDummyTabId,
+      web_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost(),
+      window_tree_host_->GetInputMethod()->GetTextInputClient());
+}
+
 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 125 matching lines @@
 
   navigation_message_sender_->ProcessMessage(std::move(message),
                                              net::CompletionCallback());
 }
 
 void BlimpEngineSession::LoadProgressChanged(
     content::WebContents* source, double progress) {
   if (source != web_contents_.get())
     return;
 
-  bool page_load_completed = progress == 1.0 ? true : false;
+  bool page_load_completed = (progress == 1.0);
 
   // If the client has been notified of a page load completed change, avoid
   // sending another message. For the first navigation, the initial value used
   // by the client is already false.
   if (last_page_load_completed_value_ == page_load_completed)
     return;
 
-  NavigationMessage* navigation_message;
+  NavigationMessage* navigation_message = nullptr;
   scoped_ptr<BlimpMessage> message =
         CreateBlimpMessage(&navigation_message, kDummyTabId);
   navigation_message->set_type(NavigationMessage::NAVIGATION_STATE_CHANGED);
-    NavigationStateChangeMessage* details =
-        navigation_message->mutable_navigation_state_changed();
+  NavigationStateChangeMessage* details =
+      navigation_message->mutable_navigation_state_changed();
   details->set_page_load_completed(page_load_completed);
 
   navigation_message_sender_->ProcessMessage(std::move(message),
                                              net::CompletionCallback());
 
   last_page_load_completed_value_ = page_load_completed;
 }
 
 void BlimpEngineSession::RenderViewCreated(
     content::RenderViewHost* render_view_host) {
@@ skipping 24 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