cros: Allow pin keyboard to keep focus without popping up the pin keyboard.

ui/keyboard/keyboard_util.cc

 // Copyright (c) 2013 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 "ui/keyboard/keyboard_util.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 26 matching lines @@
                      ui::EF_IS_SYNTHESIZED, ui::DomKey::PROCESS,
                      ui::EventTimeForNow());
   ui::EventDispatchDetails details =
       host->event_processor()->OnEventFromSource(&event);
   CHECK(!details.dispatcher_destroyed);
 }
 
 base::LazyInstance<base::Time> g_keyboard_load_time_start =
     LAZY_INSTANCE_INITIALIZER;
 
+bool g_force_disable_keyboard = false;

[bshe, 2016/11/11 17:33:36]

Is this only suppose to be changed by ScopedKeyboardDisabler? Is so, it is
probably safer to put it into scoped_keyboard_disabler so you don't need to make
SetForceDisableVirtualKeyboard a public method.

[sammiequon, 2016/11/11 21:20:58]

I'm not sure how to go about implementing this. If g_force_disable_keyboard is
removed, how do u get IsKeyboardEnabled() to check whether or not to force
disable. Thanks for any clarification.

[bshe, 2016/11/11 21:44:16]

I mean move g_force_disable_keyboard into scoped_keyboard_disabler.cc and create
a getter in the file so IsKeyboardEnabled can access. The difference is that we
don't
need to have a public setter. This feels slightly safer if you don't intent to
let other file set the
value of g_force_disable_keyboard.
It is not blocking though, so if you want to submit this CL as it is. I am fine
with it.

[sammiequon, 2016/11/11 23:14:27]

Thanks. Done.

+
 bool g_accessibility_keyboard_enabled = false;
 
 bool g_hotrod_keyboard_enabled = false;
 
 bool g_touch_keyboard_enabled = false;
 
 keyboard::KeyboardState g_requested_keyboard_state =
     keyboard::KEYBOARD_STATE_AUTO;
 
 keyboard::KeyboardOverscrolOverride g_keyboard_overscroll_override =
     keyboard::KEYBOARD_OVERSCROLL_OVERRIDE_NONE;
 
 keyboard::KeyboardShowOverride g_keyboard_show_override =
     keyboard::KEYBOARD_SHOW_OVERRIDE_NONE;
 
 }  // namespace
 
 namespace keyboard {
 
 gfx::Rect FullWidthKeyboardBoundsFromRootBounds(const gfx::Rect& root_bounds,
                                                 int keyboard_height) {
   return gfx::Rect(
       root_bounds.x(),
       root_bounds.bottom() - keyboard_height,
       root_bounds.width(),
       keyboard_height);
 }
 
+void SetForceDisableVirtualKeyboard(bool disable) {
+  g_force_disable_keyboard = disable;
+}
+
+bool GetForceDisableVirtualKeyboard() {
+  return g_force_disable_keyboard;
+}
+
 void SetAccessibilityKeyboardEnabled(bool enabled) {
   g_accessibility_keyboard_enabled = enabled;
 }
 
 bool GetAccessibilityKeyboardEnabled() {
   return g_accessibility_keyboard_enabled;
 }
 
 void SetHotrodKeyboardEnabled(bool enabled) {
   g_hotrod_keyboard_enabled = enabled;
@@ skipping 19 matching lines @@
   return g_requested_keyboard_state;
 }
 
 std::string GetKeyboardLayout() {
   // TODO(bshe): layout string is currently hard coded. We should use more
   // standard keyboard layouts.
   return GetAccessibilityKeyboardEnabled() ? "system-qwerty" : "qwerty";
 }
 
 bool IsKeyboardEnabled() {
+  // Blocks keyboard from showing up regardless of other settings.
+  if (g_force_disable_keyboard)
+    return false;
   // Accessibility setting prioritized over policy setting.
   if (g_accessibility_keyboard_enabled)
     return true;
   // Policy strictly disables showing a virtual keyboard.
   if (g_keyboard_show_override == keyboard::KEYBOARD_SHOW_OVERRIDE_DISABLED)
     return false;
   // Policy strictly enables the keyboard.
   if (g_keyboard_show_override == keyboard::KEYBOARD_SHOW_OVERRIDE_ENABLED)
     return true;
   // Run-time flag to enable keyboard has been included.
@@ skipping 248 matching lines @@
 }
 
 void LogKeyboardControlEvent(KeyboardControlEvent event) {
   UMA_HISTOGRAM_ENUMERATION(
       "VirtualKeyboard.KeyboardControlEvent",
       event,
       keyboard::KEYBOARD_CONTROL_MAX);
 }
 
 }  // namespace keyboard