Allow gaming_seat to use ozone gamepad as back-end

components/exo/gaming_seat_ozone.cc

+// Copyright 2017 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/gamepad_delegate.h"
+#include "components/exo/gaming_seat.h"
+#include "components/exo/gaming_seat_delegate.h"
+#include "components/exo/shell_surface.h"
+#include "components/exo/surface.h"
+#include "ui/events/ozone/gamepad/gamepad_provider_ozone.h"
+
+namespace {
+
+// This const is the max gamepad count supported by gaming seat.
+// TODO(jkwang) Check if we should remove this constraint when ozone backend is
+// default.
+const int kMaxGamepadCount = 4;

[reveman, 2017/06/06 21:58:55]

can we just not have this in the first place? I'm failing to see why that would
not work. The code below seem to handle it correctly, or not?

[jkwang, 2017/06/07 18:03:19]

The code below, yes. But the android counter part only support 4 gamepads. (And
the android part does not yet support connect/disconnect gamepad device
dynamically) As far as I know, call into gamepad added won't fail. Which will
cause unexpected behavior. For example, if I connect 5 gamepad with id
0,1,2,3,4. Gamepad added is called for each of them but android only handle
0,1,2,3. Later, when I disconnect 0, android will only handle 1,2,3 but will not
handle 4.

[reveman, 2017/06/07 20:29:45]

Let's not have code here that makes assumptions about the client implementation.
Especially not code that makes the implementation more complicated. Please fix
the android side instead.

[jkwang, 2017/06/07 22:01:45]

Done.

+
+}  // namespace
+
+namespace exo {
+
+GamingSeat::GamingSeat(GamingSeatDelegate* delegate,
+                       base::SingleThreadTaskRunner* task_runner)
+    : delegate_(delegate),
+      gamepad_provider_(ui::GamepadProviderOzone::GetInstance()) {
+  auto* helper = WMHelper::GetInstance();
+  helper->AddFocusObserver(this);
+  OnWindowFocused(helper->GetFocusedWindow(), nullptr);
+}
+
+GamingSeat::~GamingSeat() {
+  gamepad_provider_->RemoveGamepadObserver(this);
+  delegate_->OnGamingSeatDestroying(this);
+  // Disconnect all the gamepads.
+  for (auto& entry : gamepads_) {
+    entry.second->OnRemoved();
+  }
+
+  WMHelper::GetInstance()->RemoveFocusObserver(this);
+}
+
+void GamingSeat::OnWindowFocused(aura::Window* gained_focus,
+                                 aura::Window* lost_focus) {
+  Surface* target = nullptr;
+  if (gained_focus) {
+    target = Surface::AsSurface(gained_focus);
+    if (!target) {
+      aura::Window* top_level_window = gained_focus->GetToplevelWindow();
+      if (top_level_window)
+        target = ShellSurface::GetMainSurface(top_level_window);
+    }
+  }
+
+  bool focused = target && delegate_->CanAcceptGamepadEventsForSurface(target);
+  if (focused) {
+    gamepad_provider_->AddGamepadObserver(this);
+    OnGamepadDevicesUpdated();
+  } else {
+    gamepad_provider_->RemoveGamepadObserver(this);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// GamingSeat, Override functions for GamepadObserver.
+void GamingSeat::OnGamepadDevicesUpdated() {
+  std::vector<ui::InputDevice> gamepad_devices =
+      gamepad_provider_->GetGamepadDevices();
+
+  base::flat_map<int, GamepadDelegate*> new_gamepads;
+
+  // Copy the "still connected gamepads".
+  for (auto& device : gamepad_devices) {
+    auto it = gamepads_.find(device.id);
+    if (it != gamepads_.end()) {
+      new_gamepads[device.id] = it->second;
+      gamepads_.erase(it);
+    }
+  }
+
+  // Remove each disconected gamepad.
+  for (auto& entry : gamepads_)
+    entry.second->OnRemoved();
+
+  // Connect new connected gamepads if there is a slot.
+  for (auto& device : gamepad_devices) {
+    if (new_gamepads.size() >= kMaxGamepadCount)
+      break;
+
+    if (new_gamepads.find(device.id) == new_gamepads.end())
+      new_gamepads[device.id] = delegate_->GamepadAdded();
+  }
+
+  new_gamepads.swap(gamepads_);
+}
+
+void GamingSeat::OnGamepadEvent(const ui::GamepadEvent& event) {
+  auto it = gamepads_.find(event.device_id());
+  if (it == gamepads_.end())
+    return;
+
+  switch (event.type()) {
+    case ui::GamepadEventType::BUTTON:
+      it->second->OnButton(event.code(), event.value(), event.value());
+      break;
+    case ui::GamepadEventType::AXIS:
+      it->second->OnAxis(event.code(), event.value());
+      break;
+    case ui::GamepadEventType::FRAME:
+      it->second->OnFrame();
+      break;
+  }
+}
+
+}  // namespace exo