exo: Implement support for zcr_keyboard_configuration_v1 protocol.

components/exo/wayland/server.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/wayland/server.h"
 
 #include <grp.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <viewporter-server-protocol.h>
 #include <wayland-server-core.h>
 #include <wayland-server-protocol-core.h>
 
 // Note: core wayland headers need to be included before protocol headers.
-#include <alpha-compositing-unstable-v1-server-protocol.h>  // NOLINT
-#include <gaming-input-unstable-v1-server-protocol.h>       // NOLINT
-#include <remote-shell-unstable-v1-server-protocol.h>       // NOLINT
-#include <secure-output-unstable-v1-server-protocol.h>      // NOLINT
-#include <stylus-unstable-v1-server-protocol.h>             // NOLINT
-#include <vsync-feedback-unstable-v1-server-protocol.h>     // NOLINT
-#include <xdg-shell-unstable-v5-server-protocol.h>          // NOLINT
+#include <alpha-compositing-unstable-v1-server-protocol.h>       // NOLINT
+#include <keyboard-configuration-unstable-v1-server-protocol.h>  // NOLINT
+#include <gaming-input-unstable-v1-server-protocol.h>            // NOLINT
+#include <remote-shell-unstable-v1-server-protocol.h>            // NOLINT
+#include <secure-output-unstable-v1-server-protocol.h>           // NOLINT
+#include <stylus-unstable-v1-server-protocol.h>                  // NOLINT
+#include <vsync-feedback-unstable-v1-server-protocol.h>          // NOLINT
+#include <xdg-shell-unstable-v5-server-protocol.h>               // NOLINT
 
 #include <algorithm>
 #include <cstdlib>
 #include <iterator>
 #include <string>
 #include <utility>
 
 #include "ash/common/shell_observer.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/exo/buffer.h"
 #include "components/exo/display.h"
 #include "components/exo/gamepad.h"
 #include "components/exo/gamepad_delegate.h"
 #include "components/exo/keyboard.h"
 #include "components/exo/keyboard_delegate.h"
+#include "components/exo/keyboard_device_configuration_delegate.h"
 #include "components/exo/notification_surface.h"
 #include "components/exo/notification_surface_manager.h"
 #include "components/exo/pointer.h"
 #include "components/exo/pointer_delegate.h"
 #include "components/exo/pointer_stylus_delegate.h"
 #include "components/exo/shared_memory.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/sub_surface.h"
 #include "components/exo/surface.h"
 #include "components/exo/surface_property.h"
@@ skipping 2917 matching lines @@
 const struct zcr_pointer_stylus_v1_interface pointer_stylus_implementation = {
     pointer_stylus_destroy};
 
 ////////////////////////////////////////////////////////////////////////////////
 // stylus interface:
 
 void stylus_get_pointer_stylus(wl_client* client,
                                wl_resource* resource,
                                uint32_t id,
                                wl_resource* pointer_resource) {
+  // TODO(yhanada): Produce an erorr if a delegate already exists.
   Pointer* pointer = GetUserDataAs<Pointer>(pointer_resource);
 
   wl_resource* stylus_resource =
       wl_resource_create(client, &zcr_pointer_stylus_v1_interface, 1, id);
 
   SetImplementation(
       stylus_resource, &pointer_stylus_implementation,
       base::MakeUnique<WaylandPointerStylusDelegate>(stylus_resource, pointer));
 }
 
 const struct zcr_stylus_v1_interface stylus_implementation = {
     stylus_get_pointer_stylus};
 
 void bind_stylus(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &zcr_stylus_v1_interface, version, id);
   wl_resource_set_implementation(resource, &stylus_implementation, data,
                                  nullptr);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// keyboard_device_configuration interface:
+
+class WaylandKeyboardDeviceConfigurationDelegate
+    : public KeyboardDeviceConfigurationDelegate {
+ public:
+  WaylandKeyboardDeviceConfigurationDelegate(wl_resource* resource,
+                                             Keyboard* keyboard)
+      : resource_(resource), keyboard_(keyboard) {
+    keyboard_->SetDeviceConfigurationDelegate(this);
+  }
+  ~WaylandKeyboardDeviceConfigurationDelegate() override {
+    if (keyboard_)
+      keyboard_->SetDeviceConfigurationDelegate(nullptr);
+  }
+
+  void OnKeyboardDestroying(Keyboard* keyboard) override {
+    keyboard_ = nullptr;
+  }
+  void OnKeyboardTypeChanged(bool is_physical) override {
+    zcr_keyboard_device_configuration_v1_send_type_change(
+        resource_,
+        is_physical
+            ? ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_PHYSICAL
+            : ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_VIRTUAL);
+  }
+
+ private:
+  wl_resource* resource_;
+  Keyboard* keyboard_;
+
+  DISALLOW_COPY_AND_ASSIGN(WaylandKeyboardDeviceConfigurationDelegate);
+};
+
+void keyboard_device_configuration_destroy(wl_client* client,
+                                           wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
+const struct zcr_keyboard_device_configuration_v1_interface
+    keyboard_device_configuration_implementation = {
+        keyboard_device_configuration_destroy};
+
+////////////////////////////////////////////////////////////////////////////////
+// keyboard_configuration interface:
+
+void keyboard_configuration_get_keyboard_device_configuration(
+    wl_client* client,
+    wl_resource* resource,
+    uint32_t id,
+    wl_resource* keyboard_resource) {
+  // TODO(yhanada): Produce an error if a delegate already exists.
+  wl_resource* keyboard_device_configuration_resource = wl_resource_create(
+      client, &zcr_keyboard_device_configuration_v1_interface, 1, id);
+
+  SetImplementation(
+      keyboard_device_configuration_resource,
+      &keyboard_device_configuration_implementation,
+      base::MakeUnique<WaylandKeyboardDeviceConfigurationDelegate>(
+          keyboard_device_configuration_resource,
+          GetUserDataAs<Keyboard>(keyboard_resource)));
+}
+
+const struct zcr_keyboard_configuration_v1_interface
+    keyboard_configuration_implementation = {
+        keyboard_configuration_get_keyboard_device_configuration};
+
+void bind_keyboard_configuration(wl_client* client,
+                                 void* data,
+                                 uint32_t version,
+                                 uint32_t id) {
+  wl_resource* resource = wl_resource_create(
+      client, &zcr_keyboard_configuration_v1_interface, version, id);
+  wl_resource_set_implementation(
+      resource, &keyboard_configuration_implementation, data, nullptr);
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Server, public:
 
 Server::Server(Display* display)
     : display_(display), wl_display_(wl_display_create()) {
   wl_global_create(wl_display_.get(), &wl_compositor_interface,
                    compositor_version, display_, bind_compositor);
   wl_global_create(wl_display_.get(), &wl_shm_interface, 1, display_, bind_shm);
@@ skipping 22 matching lines @@
   wl_global_create(wl_display_.get(), &zcr_secure_output_v1_interface, 1,
                    display_, bind_secure_output);
   wl_global_create(wl_display_.get(), &zcr_alpha_compositing_v1_interface, 1,
                    display_, bind_alpha_compositing);
   wl_global_create(wl_display_.get(), &zcr_remote_shell_v1_interface,
                    remote_shell_version, display_, bind_remote_shell);
   wl_global_create(wl_display_.get(), &zcr_gaming_input_v1_interface, 1,
                    display_, bind_gaming_input);
   wl_global_create(wl_display_.get(), &zcr_stylus_v1_interface, 1, display_,
                    bind_stylus);
+  wl_global_create(wl_display_.get(), &zcr_keyboard_configuration_v1_interface,
+                   1, display_, bind_keyboard_configuration);
 }
 
 Server::~Server() {}
 
 // static
 std::unique_ptr<Server> Server::Create(Display* display) {
   std::unique_ptr<Server> server(new Server(display));
 
   char* runtime_dir = getenv("XDG_RUNTIME_DIR");
   if (!runtime_dir) {
@@ skipping 51 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo