Extracting placeholder information from Webkit to Blimp

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 <utility>
 
 #include "base/command_line.h"
@@ skipping 210 matching lines @@
     std::unique_ptr<BlimpBrowserContext> browser_context,
     net::NetLog* net_log,
     BlimpEngineConfig* engine_config,
     SettingsManager* settings_manager)
     : screen_(new BlimpScreen),
       browser_context_(std::move(browser_context)),
       engine_config_(engine_config),
       settings_manager_(settings_manager),
       settings_feature_(settings_manager_),
       render_widget_feature_(settings_manager_),
-      net_components_(new EngineNetworkComponents(net_log)) {
+      net_components_(new EngineNetworkComponents(net_log)),
+      weak_factory_(this) {
   DCHECK(engine_config_);
   DCHECK(settings_manager_);
 
   screen_->UpdateDisplayScaleAndSize(
       kDefaultScaleFactor,
       gfx::Size(kDefaultDisplayWidth, kDefaultDisplayHeight));
 
   std::unique_ptr<HeliumBlobSenderDelegate> helium_blob_delegate(
       new HeliumBlobSenderDelegate);
   blob_delegate_ = helium_blob_delegate.get();
@@ skipping 153 matching lines @@
 //  - 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 (!tab_ || !tab_->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(
         tab_->tab_id(),
         tab_->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() {
   TRACE_EVENT0("blimp", "BlimpEngineSession::OnShowImeIfNeeded");
   if (!tab_ || !tab_->web_contents()->GetRenderWidgetHostView() ||
       !window_tree_host_->GetInputMethod()->GetTextInputClient())
     return;
 
+  base::Callback<void(const std::string&, const std::string&)> reply =

[David Trainor- moved to gerrit, 2016/10/26 01:36:42]

This should probably live inside Tab so we can do a bunch of extra tracking.

1. It'll be specific to the tab that called it (if tabs change you won't get a
show IME request for the wrong tab).
2. If we ever get another show IME request we should wait for the callback to
complete, drop the results, and call the callback again (IMO).

[shaktisahu, 2016/10/31 23:13:58]

Done.

+      base::Bind(&BlimpEngineSession::FetchTextInputInfo,
+                 weak_factory_.GetWeakPtr());
+
+  tab_->web_contents()->GetRenderWidgetHostView()->FetchTextInputInfo(reply);
+}
+
+void BlimpEngineSession::FetchTextInputInfo(const std::string& text,
+                                            const std::string& placeholder) {
+  ui::TextInputType type = window_tree_host_->GetInputMethod()
+                               ->GetTextInputClient()
+                               ->GetTextInputType();
   render_widget_feature_.SendShowImeRequest(
       tab_->tab_id(),
       tab_->web_contents()->GetRenderWidgetHostView()->GetRenderWidgetHost(),
-      window_tree_host_->GetInputMethod()->GetTextInputClient());
+      type, text, placeholder);
 }
 
 void BlimpEngineSession::ProcessMessage(
     std::unique_ptr<BlimpMessage> message,
     const net::CompletionCallback& callback) {
   TRACE_EVENT1("blimp", "BlimpEngineSession::ProcessMessage", "TabId",
                message->target_tab_id());
   DCHECK(!callback.is_null());
   DCHECK(BlimpMessage::kTabControl == message->feature_case() ||
          BlimpMessage::kNavigation == message->feature_case());
@@ skipping 127 matching lines @@
     parent->AddChild(content);
   content->Show();
 
   tab_ = base::MakeUnique<Tab>(std::move(new_contents), target_tab_id,
                                &render_widget_feature_,
                                navigation_message_sender_.get());
 }
 
 }  // namespace engine
 }  // namespace blimp