Refactored gamepad polling to support dynamic sources

components/exo/gamepad.cc

 // Copyright 2016 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.h"
 
 #include <cmath>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/exo/gamepad_delegate.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/surface.h"
 #include "device/gamepad/gamepad_data_fetcher.h"
-#include "device/gamepad/gamepad_platform_data_fetcher.h"
+#include "device/gamepad/gamepad_pad_state_provider.h"
+#include "device/gamepad/gamepad_platform_data_fetcher_linux.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 
 namespace exo {
 namespace {
 
 constexpr double kGamepadButtonValueEpsilon = 0.001;
 bool GamepadButtonValuesAreEqual(double a, double b) {
   return fabs(a - b) < kGamepadButtonValueEpsilon;
 }
 
 std::unique_ptr<device::GamepadDataFetcher> CreateGamepadPlatformDataFetcher() {
   return std::unique_ptr<device::GamepadDataFetcher>(
-      new device::GamepadPlatformDataFetcher());
+      new device::GamepadPlatformDataFetcherLinux());
 }
 
 // Time between gamepad polls in milliseconds.
 constexpr unsigned kPollingTimeIntervalMs = 16;
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Gamepad::ThreadSafeGamepadChangeFetcher
 
 // Implements all methods and resources running on the polling thread.
 // This class is reference counted to allow it to shut down safely on the
 // polling thread even if the Gamepad has been destroyed on the origin thread.
 class Gamepad::ThreadSafeGamepadChangeFetcher
-    : public base::RefCountedThreadSafe<
+    : public device::GamepadPadStateProvider,
+      public base::RefCountedThreadSafe<
           Gamepad::ThreadSafeGamepadChangeFetcher> {
  public:
   using ProcessGamepadChangesCallback =
       base::Callback<void(const blink::WebGamepad)>;
 
   ThreadSafeGamepadChangeFetcher(
       const ProcessGamepadChangesCallback& post_gamepad_changes,
       const CreateGamepadDataFetcherCallback& create_fetcher_callback,
       base::SingleThreadTaskRunner* task_runner)
       : process_gamepad_changes_(post_gamepad_changes),
         create_fetcher_callback_(create_fetcher_callback),
         polling_task_runner_(task_runner),
         origin_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
     thread_checker_.DetachFromThread();
   }
 
   // Enable or disable gamepad polling. Can be called from any thread.
   void EnablePolling(bool enabled) {
     polling_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &ThreadSafeGamepadChangeFetcher::EnablePollingOnPollingThread,
             make_scoped_refptr(this), enabled));
   }
 
  private:
   friend class base::RefCountedThreadSafe<ThreadSafeGamepadChangeFetcher>;
 
-  virtual ~ThreadSafeGamepadChangeFetcher() {}
+  ~ThreadSafeGamepadChangeFetcher() override {}
 
   // Enables or disables polling.
   void EnablePollingOnPollingThread(bool enabled) {
     DCHECK(thread_checker_.CalledOnValidThread());
     is_enabled_ = enabled;
 
     if (is_enabled_) {
       if (!fetcher_) {
         fetcher_ = create_fetcher_callback_.Run();
+        InitializeDataFetcher(fetcher_.get());
         DCHECK(fetcher_);
       }
       SchedulePollOnPollingThread();
     } else {
       fetcher_.reset();
     }
   }
 
   // Schedules the next poll on the polling thread.
   void SchedulePollOnPollingThread() {
@@ skipping 15 matching lines @@
   void PollOnPollingThread() {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     has_poll_scheduled_ = false;
     if (!is_enabled_)
       return;
 
     DCHECK(fetcher_);
 
     blink::WebGamepads new_state = state_;
-    fetcher_->GetGamepadData(&new_state, false);
+    fetcher_->GetGamepadData(
+        false /* No hardware changed notification from the system */);
+
+    new_state.length = 0;
+    device::PadState& pad_state = pad_states_.get()[0];
+
+    // After querying the gamepad clear the state if it did not have it's active
+    // state updated but is still listed as being associated with a specific
+    // source. This indicates the gamepad is disconnected.
+    if (!pad_state.active_state &&
+        pad_state.source != device::GAMEPAD_SOURCE_NONE) {
+      ClearPadState(pad_state);
+    }
+
+    MapAndSanitizeGamepadData(&pad_state, &new_state.items[0],
+                              false /* Don't sanitize gamepad data */);
+
+    // If the gamepad was active then increment the length of the WebGamepads
+    // struct to indicate it's valid, then set the pad state to inactive. If the
+    // gamepad is still actively reporting the next call to GetGamepadData will
+    // set the active state to active again.
+    if (pad_state.active_state) {
+      new_state.length++;
+      pad_state.active_state = device::GAMEPAD_INACTIVE;
+    }
 
     if (std::max(new_state.length, state_.length) > 0) {
       if (new_state.items[0].connected != state_.items[0].connected ||
           new_state.items[0].timestamp > state_.items[0].timestamp) {
         origin_task_runner_->PostTask(
             FROM_HERE,
             base::Bind(process_gamepad_changes_, new_state.items[0]));
       }
     }
 
@@ skipping 123 matching lines @@
       delegate_->OnButton(button_id, new_button.pressed, new_button.value);
     }
   }
   if (send_frame)
     delegate_->OnFrame();
 
   pad_state_ = new_pad;
 }
 
 }  // namespace exo