The on screen keyboard on Windows 8+ should not obscure the input field.

content/browser/renderer_host/render_view_host_impl.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_view_host_impl.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 72 matching lines @@
 #include "ui/base/touch/touch_device.h"
 #include "ui/base/touch/touch_enabled.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/native_theme/native_theme_switches.h"
 #include "url/url_constants.h"
 
 #if defined(OS_WIN)
-#include "base/win/win_util.h"
 #include "ui/display/win/dpi.h"
+#include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/platform_font_win.h"
 #endif
 
 using base::TimeDelta;
 using blink::WebConsoleMessage;
 using blink::WebDragOperation;
 using blink::WebDragOperationNone;
 using blink::WebDragOperationsMask;
 using blink::WebInputEvent;
 using blink::WebMediaPlayerAction;
 using blink::WebPluginAction;
 
 namespace content {
 namespace {
 
 #if defined(OS_WIN)
-
-const int kVirtualKeyboardDisplayWaitTimeoutMs = 100;
-const int kMaxVirtualKeyboardDisplayRetries = 5;
-
-void DismissVirtualKeyboardTask() {
-  static int virtual_keyboard_display_retries = 0;
-  // If the virtual keyboard is not yet visible, then we execute the task again
-  // waiting for it to show up.
-  if (!base::win::DismissVirtualKeyboard()) {
-    if (virtual_keyboard_display_retries < kMaxVirtualKeyboardDisplayRetries) {
-      BrowserThread::PostDelayedTask(
-          BrowserThread::UI, FROM_HERE,
-          base::Bind(base::IgnoreResult(&DismissVirtualKeyboardTask)),
-          TimeDelta::FromMilliseconds(kVirtualKeyboardDisplayWaitTimeoutMs));
-      ++virtual_keyboard_display_retries;
-    } else {
-      virtual_keyboard_display_retries = 0;
-    }
-  }
-}
-
 void GetWindowsSpecificPrefs(RendererPreferences* prefs) {
   NONCLIENTMETRICS_XP metrics = {0};
   base::win::GetNonClientMetrics(&metrics);
 
   prefs->caption_font_family_name = metrics.lfCaptionFont.lfFaceName;
   prefs->caption_font_height = gfx::PlatformFontWin::GetFontSize(
       metrics.lfCaptionFont);
 
   prefs->small_caption_font_family_name = metrics.lfSmCaptionFont.lfFaceName;
   prefs->small_caption_font_height = gfx::PlatformFontWin::GetFontSize(
@@ skipping 14 matching lines @@
   prefs->vertical_scroll_bar_width_in_dips =
       display::win::GetSystemMetricsInDIP(SM_CXVSCROLL);
   prefs->horizontal_scroll_bar_height_in_dips =
       display::win::GetSystemMetricsInDIP(SM_CYHSCROLL);
   prefs->arrow_bitmap_height_vertical_scroll_bar_in_dips =
       display::win::GetSystemMetricsInDIP(SM_CYVSCROLL);
   prefs->arrow_bitmap_width_horizontal_scroll_bar_in_dips =
       display::win::GetSystemMetricsInDIP(SM_CXHSCROLL);
 }
 #endif
-
 }  // namespace
 
 // static
 const int64_t RenderViewHostImpl::kUnloadTimeoutMS = 1000;
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderViewHost, public:
 
 // static
 RenderViewHost* RenderViewHost::FromID(int render_process_id,
@@ skipping 43 matching lines @@
       delegate_(delegate),
       instance_(static_cast<SiteInstanceImpl*>(instance)),
       enabled_bindings_(0),
       page_id_(-1),
       is_active_(!swapped_out),
       is_swapped_out_(swapped_out),
       main_frame_routing_id_(main_frame_routing_id),
       is_waiting_for_close_ack_(false),
       sudden_termination_allowed_(false),
       render_view_termination_status_(base::TERMINATION_STATUS_STILL_RUNNING),
-      virtual_keyboard_requested_(false),
       is_focused_element_editable_(false),
       updating_web_preferences_(false),
       render_view_ready_on_process_launch_(false),
       weak_factory_(this) {
   DCHECK(instance_.get());
   CHECK(delegate_);  // http://crbug.com/82827
 
   GetWidget()->set_owner_delegate(this);
 
   GetProcess()->AddObserver(this);
@@ skipping 879 matching lines @@
   if (view)
     view->TakeFocus(reverse);
 }
 
 void RenderViewHostImpl::OnFocusedNodeChanged(
     bool is_editable_node,
     const gfx::Rect& node_bounds_in_viewport) {
   is_focused_element_editable_ = is_editable_node;
   if (GetWidget()->GetView())
     GetWidget()->GetView()->FocusedNodeChanged(is_editable_node);
-#if defined(OS_WIN)
-  if (!is_editable_node && virtual_keyboard_requested_) {
-    virtual_keyboard_requested_ = false;
-    delegate_->SetIsVirtualKeyboardRequested(false);
-    BrowserThread::PostDelayedTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(base::IgnoreResult(&DismissVirtualKeyboardTask)),
-        TimeDelta::FromMilliseconds(kVirtualKeyboardDisplayWaitTimeoutMs));
-  }
-#endif
 
   // None of the rest makes sense without a view.
   if (!GetWidget()->GetView())
     return;
 
   // Convert node_bounds to screen coordinates.
   gfx::Rect view_bounds_in_screen = GetWidget()->GetView()->GetViewBounds();
   gfx::Point origin = node_bounds_in_viewport.origin();
   origin.Offset(view_bounds_in_screen.x(), view_bounds_in_screen.y());
   gfx::Rect node_bounds_in_screen(origin.x(), origin.y(),
@@ skipping 142 matching lines @@
     bad_message::ReceivedBadMessage(GetProcess(),
                                     bad_message::RVH_FILE_CHOOSER_PATH);
     return;
   }
 
   delegate_->RunFileChooser(this, params);
 }
 
 void RenderViewHostImpl::OnFocusedNodeTouched(bool editable) {
 #if defined(OS_WIN)
-  if (editable) {
-    virtual_keyboard_requested_ = base::win::DisplayVirtualKeyboard();
-    delegate_->SetIsVirtualKeyboardRequested(true);
-  } else {
-    virtual_keyboard_requested_ = false;
-    delegate_->SetIsVirtualKeyboardRequested(false);
-    base::win::DismissVirtualKeyboard();
-  }
+  // We use the cursor position to determine where the touch occurred.
+  // TODO(ananta)
+  // Pass this information from blink.

[ncarter (slow), 2016/05/19 21:46:15]

Getting the info from blink probably makes sense (assuming we can trust it).
Fwiw, it might also be possible to grab it from the InputRouter (kind of like
GetLastKeyboardEvent()) but I don't know which is a better design.

[ananta, 2016/05/19 22:00:56]

Yes. We can revisit this in the near future.

+  POINT cursor_pos = {};
+  ::GetCursorPos(&cursor_pos);
+  float scale = GetScaleFactorForView(GetWidget()->GetView());
+  gfx::Point location_dips =
+      gfx::ConvertPointToDIP(scale, gfx::Point(cursor_pos));
+  if (GetWidget()->GetView())
+    GetWidget()->GetView()->FocusedNodeTouched(location_dips, editable);
 #endif
 }
 
 bool RenderViewHostImpl::CanAccessFilesOfPageState(
     const PageState& state) const {
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
   const std::vector<base::FilePath>& file_paths = state.GetReferencedFiles();
   for (const auto& file : file_paths) {
@@ skipping 28 matching lines @@
   } else {
     render_view_ready_on_process_launch_ = true;
   }
 }
 
 void RenderViewHostImpl::RenderViewReady() {
   delegate_->RenderViewReady(this);
 }
 
 }  // namespace content