exo: Implement support for zcr_keyboard_configuration_v1 protocol.

components/exo/keyboard.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 "components/exo/keyboard.h"
 
 #include "components/exo/keyboard_delegate.h"
+#include "components/exo/keyboard_device_configuration_delegate.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/surface.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/events/base_event_utils.h"
+#include "ui/events/devices/input_device.h"
+#include "ui/events/devices/input_device_manager.h"
 #include "ui/events/event.h"
 #include "ui/views/widget/widget.h"
 
 namespace exo {
+namespace {
 
 bool ConsumedByIme(Surface* focus, const ui::KeyEvent* event) {
   // Check if IME consumed the event, to avoid it to be doubly processed.
   // First let us see whether IME is active and is in text input mode.
   views::Widget* widget =
       focus ? views::Widget::GetTopLevelWidgetForNativeView(focus->window())
             : nullptr;
   ui::InputMethod* ime = widget ? widget->GetInputMethod() : nullptr;
   if (!ime || ime->GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return false;
@@ skipping 35 matching lines @@
   if ((event->flags() & kModifierMask) == 0) {
     if (event->key_code() == ui::VKEY_RETURN ||
         event->key_code() == ui::VKEY_BACK) {
       return true;
     }
   }
 
   return false;
 }
 
+bool IsPhysicalKeyboardEnabled() {
+  // The internal keyboard is enabled if maximize mode is not enabled.
+  if (WMHelper::GetInstance()->IsMaximizeModeWindowManagerEnabled())
+    return true;
+
+  for (auto& keyboard :
+       ui::InputDeviceManager::GetInstance()->GetKeyboardDevices()) {
+    if (keyboard.type != ui::InputDeviceType::INPUT_DEVICE_INTERNAL)
+      return true;
+  }
+  return false;
+}
+
+}  // namespace
+
 ////////////////////////////////////////////////////////////////////////////////
 // Keyboard, public:
 
 Keyboard::Keyboard(KeyboardDelegate* delegate) : delegate_(delegate) {
   auto* helper = WMHelper::GetInstance();
   helper->AddPostTargetHandler(this);
   helper->AddFocusObserver(this);
+  helper->AddMaximizeModeObserver(this);
+  helper->AddInputDeviceEventObserver(this);
   OnWindowFocused(helper->GetFocusedWindow(), nullptr);
 }
 
 Keyboard::~Keyboard() {
   delegate_->OnKeyboardDestroying(this);
+  if (device_configuration_delegate_)
+    device_configuration_delegate_->OnKeyboardDestroying(this);
   if (focus_)
     focus_->RemoveSurfaceObserver(this);
   auto* helper = WMHelper::GetInstance();
   helper->RemoveFocusObserver(this);
   helper->RemovePostTargetHandler(this);
+  helper->RemoveMaximizeModeObserver(this);
+  helper->RemoveInputDeviceEventObserver(this);
+}
+
+void Keyboard::SetDeviceConfigurationDelegate(
+    KeyboardDeviceConfigurationDelegate* delegate) {
+  device_configuration_delegate_ = delegate;
+  OnKeyboardDeviceConfigurationChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void Keyboard::OnKeyEvent(ui::KeyEvent* event) {
   // These modifiers reflect what Wayland is aware of.  For example,
   // EF_SCROLL_LOCK_ON is missing because Wayland doesn't support scroll lock.
   const int kModifierMask = ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                             ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN |
@@ skipping 63 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceObserver overrides:
 
 void Keyboard::OnSurfaceDestroying(Surface* surface) {
   DCHECK(surface == focus_);
   focus_ = nullptr;
   surface->RemoveSurfaceObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// ui::InputDeviceEventObserver overrides:
+
+void Keyboard::OnKeyboardDeviceConfigurationChanged() {
+  if (device_configuration_delegate_) {
+    device_configuration_delegate_->OnKeyboardTypeChanged(
+        IsPhysicalKeyboardEnabled());
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// WMHelper::MaximizeModeObserver overrides:
+
+void Keyboard::OnMaximizeModeStarted() {
+  OnKeyboardDeviceConfigurationChanged();
+}
+
+void Keyboard::OnMaximizeModeEnded() {
+  OnKeyboardDeviceConfigurationChanged();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Keyboard, private:
 
 Surface* Keyboard::GetEffectiveFocus(aura::Window* window) const {
   // Use window surface as effective focus.
   Surface* focus = Surface::AsSurface(window);
   if (!focus) {
     // Fallback to main surface.
     aura::Window* top_level_window = window->GetToplevelWindow();
     if (top_level_window)
       focus = ShellSurface::GetMainSurface(top_level_window);
   }
 
   return focus && delegate_->CanAcceptKeyboardEventsForSurface(focus) ? focus
                                                                       : nullptr;
 }
 
 }  // namespace exo