Adjust appearance of omnibox keyword hint view for on-screen keyboards.

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 10 matching lines @@
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "ui/keyboard/keyboard_ui.h"
 #include "ui/keyboard/scoped_keyboard_disabler.h"
 
+namespace keyboard {
+
 namespace {
 
 const char kKeyDown[] ="keydown";
 const char kKeyUp[] = "keyup";
 
 void SendProcessKeyEvent(ui::EventType type,
                          aura::WindowTreeHost* host) {
   ui::KeyEvent event(type, ui::VKEY_PROCESSKEY, ui::DomCode::NONE,
                      ui::EF_IS_SYNTHESIZED, ui::DomKey::PROCESS,
                      ui::EventTimeForNow());
   ui::EventDispatchDetails details =
       host->event_sink()->OnEventFromSource(&event);
   CHECK(!details.dispatcher_destroyed);
 }
 
 base::LazyInstance<base::Time>::DestructorAtExit g_keyboard_load_time_start =
     LAZY_INSTANCE_INITIALIZER;
 
 bool g_accessibility_keyboard_enabled = false;
 
 bool g_hotrod_keyboard_enabled = false;
 
 bool g_keyboard_restricted = false;
 
 bool g_touch_keyboard_enabled = false;
 
 bool g_overscroll_enabled_with_accessibility_keyboard = false;
 
-keyboard::KeyboardState g_requested_keyboard_state =
-    keyboard::KEYBOARD_STATE_AUTO;
+KeyboardState g_requested_keyboard_state = KEYBOARD_STATE_AUTO;
 
-keyboard::KeyboardOverscrolOverride g_keyboard_overscroll_override =
-    keyboard::KEYBOARD_OVERSCROLL_OVERRIDE_NONE;
+KeyboardOverscrolOverride g_keyboard_overscroll_override =
+    KEYBOARD_OVERSCROLL_OVERRIDE_NONE;
 
-keyboard::KeyboardShowOverride g_keyboard_show_override =
-    keyboard::KEYBOARD_SHOW_OVERRIDE_NONE;
+KeyboardShowOverride g_keyboard_show_override = 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 SetAccessibilityKeyboardEnabled(bool enabled) {
@@ skipping 35 matching lines @@
 }
 
 bool IsKeyboardEnabled() {
   // Blocks keyboard from showing up regardless of other settings.
   if (ScopedKeyboardDisabler::GetForceDisableVirtualKeyboard())
     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)
+  if (g_keyboard_show_override == KEYBOARD_SHOW_OVERRIDE_DISABLED)
     return false;
   // Policy strictly enables the keyboard.
-  if (g_keyboard_show_override == keyboard::KEYBOARD_SHOW_OVERRIDE_ENABLED)
+  if (g_keyboard_show_override == KEYBOARD_SHOW_OVERRIDE_ENABLED)
     return true;
   // Run-time flag to enable keyboard has been included.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableVirtualKeyboard))
     return true;
   // Requested state from the application layer.
-  if (g_requested_keyboard_state == keyboard::KEYBOARD_STATE_DISABLED)
+  if (g_requested_keyboard_state == KEYBOARD_STATE_DISABLED)
     return false;
   // Check if any of the other flags are enabled.
   return g_touch_keyboard_enabled ||
-         g_requested_keyboard_state == keyboard::KEYBOARD_STATE_ENABLED;
+         g_requested_keyboard_state == KEYBOARD_STATE_ENABLED;
+}
+
+bool IsKeyboardVisible() {
+  auto* keyboard_controller = keyboard::KeyboardController::GetInstance();
+  return keyboard_controller && keyboard_controller->keyboard_visible();
 }
 
 bool IsKeyboardOverscrollEnabled() {
   if (!IsKeyboardEnabled())
     return false;
 
   // Users of the accessibility on-screen keyboard are likely to be using mouse
   // input, which may interfere with overscrolling.
   if (g_accessibility_keyboard_enabled &&
       !g_overscroll_enabled_with_accessibility_keyboard) {
@@ skipping 60 matching lines @@
       switches::kDisableSmartVirtualKeyboard);
 }
 
 bool IsVoiceInputEnabled() {
   return !g_keyboard_restricted &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kDisableVoiceInput);
 }
 
 bool InsertText(const base::string16& text) {
-  keyboard::KeyboardController* controller = KeyboardController::GetInstance();
+  KeyboardController* controller = KeyboardController::GetInstance();
   if (!controller)
     return false;
 
   ui::InputMethod* input_method = controller->ui()->GetInputMethod();
   if (!input_method)
     return false;
 
   ui::TextInputClient* tic = input_method->GetTextInputClient();
   if (!tic || tic->GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return false;
@@ skipping 151 matching lines @@
   if (!logged) {
     // Log the delta only once.
     UMA_HISTOGRAM_TIMES(
         "VirtualKeyboard.InitLatency.FirstLoad",
         base::Time::Now() - g_keyboard_load_time_start.Get());
     logged = true;
   }
 }
 
 void LogKeyboardControlEvent(KeyboardControlEvent event) {
-  UMA_HISTOGRAM_ENUMERATION(
-      "VirtualKeyboard.KeyboardControlEvent",
-      event,
-      keyboard::KEYBOARD_CONTROL_MAX);
+  UMA_HISTOGRAM_ENUMERATION("VirtualKeyboard.KeyboardControlEvent", event,
+                            KEYBOARD_CONTROL_MAX);
 }
 
 void SetOverscrollEnabledWithAccessibilityKeyboard(bool enabled) {
   g_overscroll_enabled_with_accessibility_keyboard = enabled;
 }
 
 }  // namespace keyboard