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 "blimp/common/create_blimp_message.h"
@@ skipping 20 matching lines @@
 #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/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 112 matching lines @@
   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);

[nyquist, 2016/03/10 00:57:13]

Does this observer need to be removed? Also, this seems like a possible place
for the hookup of the observer unless you of course (maybe better?) do it in the
feature class instead.

[shaktisahu, 2016/03/15 23:44:13]

Done.

+
   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_));
+  ime_message_sender_ =
+      thread_pipe_manager_->RegisterFeature(BlimpMessage::IME, this);

[nyquist, 2016/03/10 00:57:13]

I was hoping we wouldn't have to pass in |this| here.

[shaktisahu, 2016/03/15 23:44:13]

Done.

 }
 
 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(

[nyquist, 2016/03/10 00:58:48]

And this should hoepfully be tested as well.

+    const ui::TextInputClient* client) {

[Khushal, 2016/03/10 07:54:10]

The RenderWidgetHostView is also a text input client, and I think you should get
this call when it becomes focused and should be the one sending these events.

So perhaps, save a reference to the TextInputClient here. And when you get the
OnShowImeIfNeeded call, make sure that it is the current RenderWidgetHostView,

if (!client_)
   return;

if (client_ != web_contents_->GetRenderWidgetHostView()->GetTextInputClient())
   return;

This way you can add the id for the RenderWidget generated in
EngineRenderWidgetFeature to the ime messages sent to the client.
When you are receiving messages from the client, discard the message if the
RenderWidgetHost has been deleted or it is not the current RenderWidgetHost. And
use the text input client from the RenderWidgetHostView to forward the ime event
to.

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

[nyquist, 2016/03/10 00:57:13]

Nit: Braces are optional for single-line statements.

+    ShowIme(false);
+  }
+}
+
+void BlimpEngineSession::OnInputMethodDestroyed(
+    const ui::InputMethod* input_method) {}
+
+// Called when a user input should trigger showing the IME.
+void BlimpEngineSession::OnShowImeIfNeeded() {
+  ShowIme(true);
+}
+
+void BlimpEngineSession::ShowIme(bool show) {

[nyquist, 2016/03/10 00:58:48]

It feels like this should be tested.

+  ImeMessage* ime_message;
+  scoped_ptr<BlimpMessage> blimp_message = CreateBlimpMessage(&ime_message);

[David Trainor- moved to gerrit, 2016/03/14 17:59:42]

We probably also want to attach the tab id and the render widget id?

[shaktisahu, 2016/03/15 23:44:13]

Done.

+
+  ime_message->set_type(show ? ImeMessage::SHOW_IME : ImeMessage::HIDE_IME);
+
+  ui::TextInputClient* client =
+      window_tree_host_->GetInputMethod()->GetTextInputClient();
+
+  gfx::Range text_range;
+  base::string16 existing_text;
+  client->GetTextRange(&text_range);
+  client->GetTextFromRange(text_range, &existing_text);
+
+  ime_message->set_text_input_type(client->GetTextInputType());

[David Trainor- moved to gerrit, 2016/03/14 17:59:42]

We should pull this out to some protocol format and write some converters :).

[shaktisahu, 2016/03/15 23:44:13]

Done.

+  ime_message->set_ime_text(base::UTF16ToUTF8(existing_text));
+  ime_message_sender_->ProcessMessage(std::move(blimp_message),
+                                      net::CompletionCallback());
+}
+
 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);
+         message->type() == BlimpMessage::NAVIGATION ||
+         message->type() == BlimpMessage::IME);
 
   net::Error result = net::OK;
   if (message->type() == BlimpMessage::TAB_CONTROL) {
     switch (message->tab_control().type()) {
       case TabControlMessage::CREATE_TAB:
         if (!CreateWebContents(message->target_tab_id()))
           result = net::ERR_FAILED;
         break;
       case TabControlMessage::CLOSE_TAB:
         CloseWebContents(message->target_tab_id());
@@ skipping 18 matching lines @@
       case NavigationMessage::GO_FORWARD:
         GoForward(message->target_tab_id());
         break;
       case NavigationMessage::RELOAD:
         Reload(message->target_tab_id());
         break;
       default:
         NOTIMPLEMENTED();
         result = net::ERR_NOT_IMPLEMENTED;
     }
+  } else if (message->type() == BlimpMessage::IME) {

[nyquist, 2016/03/10 00:58:48]

And this should hopefully be tested?

+    const ImeMessage& ime = message->ime();
+    DCHECK(ime.type() == ImeMessage::SHOW_TEXT);
+
+    ui::TextInputClient* client =
+        window_tree_host_->GetInputMethod()->GetTextInputClient();
+
+    if (client && client->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
+      // Clear out any existing text first and
+      // then insert new text entered through IME.
+      gfx::Range text_range;
+      client->GetTextRange(&text_range);
+      client->ExtendSelectionAndDelete(text_range.length(),
+                                       text_range.length());
+
+      client->InsertText(base::UTF8ToUTF16(ime.ime_text()));
+    }
   } else {
     DVLOG(1) << "No WebContents for navigation control";
     result = net::ERR_FAILED;
   }
 
   callback.Run(result);
 }
 
 void BlimpEngineSession::AddNewContents(content::WebContents* source,
                                         content::WebContents* new_contents,
@@ skipping 112 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