[Device Service] Move Gamepad Blink headers to be part of the Gamepad client library

components/exo/gaming_seat.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/gaming_seat.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 32 matching lines @@
 
 // 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 GamingSeat::ThreadSafeGamepadChangeFetcher
     : public device::GamepadPadStateProvider,
       public base::RefCountedThreadSafe<
           GamingSeat::ThreadSafeGamepadChangeFetcher> {
  public:
   using ProcessGamepadChangesCallback =
-      base::Callback<void(int index, const blink::WebGamepad)>;
+      base::Callback<void(int index, const device::Gamepad)>;
 
   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();
@@ skipping 49 matching lines @@
   // Polls devices for new data and posts gamepad changes back to origin thread.
   void PollOnPollingThread() {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     has_poll_scheduled_ = false;
     if (!is_enabled_)
       return;
 
     DCHECK(fetcher_);
 
-    blink::WebGamepads new_state = state_;
+    device::Gamepads new_state = state_;
     fetcher_->GetGamepadData(
         false /* No hardware changed notification from the system */);
 
-    for (size_t i = 0; i < blink::WebGamepads::kItemsLengthCap; ++i) {
+    for (size_t i = 0; i < device::Gamepads::kItemsLengthCap; ++i) {
       device::PadState& pad_state = pad_states_.get()[i];
 
       // 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);
       }
@@ skipping 26 matching lines @@
   // Reference to task runner on polling thread.
   scoped_refptr<base::SingleThreadTaskRunner> polling_task_runner_;
 
   // Reference to task runner on origin thread.
   scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
 
   // Gamepad data fetcher used for querying gamepad devices.
   std::unique_ptr<device::GamepadDataFetcher> fetcher_;
 
   // The current state of all gamepads.
-  blink::WebGamepads state_;
+  device::Gamepads state_;
 
   // True if a poll has been scheduled.
   bool has_poll_scheduled_ = false;
 
   // True if the polling thread is paused.
   bool is_enabled_ = false;
 
   // ThreadChecker for the polling thread.
   base::ThreadChecker thread_checker_;
 
@@ skipping 24 matching lines @@
   helper->AddFocusObserver(this);
   OnWindowFocused(helper->GetFocusedWindow(), nullptr);
 }
 
 GamingSeat::~GamingSeat() {
   // Disable polling. Since ThreadSafeGamepadChangeFetcher are reference
   // counted, we can safely have it shut down after Gamepad has been destroyed.
   gamepad_change_fetcher_->EnablePolling(false);
 
   delegate_->OnGamingSeatDestroying(this);
-  for (size_t i = 0; i < blink::WebGamepads::kItemsLengthCap; ++i) {
+  for (size_t i = 0; i < device::Gamepads::kItemsLengthCap; ++i) {
     if (gamepad_delegates_[i]) {
       gamepad_delegates_[i]->OnRemoved();
     }
   }
   WMHelper::GetInstance()->RemoveFocusObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // aura::client::FocusChangeObserver overrides:
 
@@ skipping 12 matching lines @@
 
   bool focused = target && delegate_->CanAcceptGamepadEventsForSurface(target);
 
   gamepad_change_fetcher_->EnablePolling(focused);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GamingSeat, private:
 
 void GamingSeat::ProcessGamepadChanges(int index,
-                                       const blink::WebGamepad new_pad) {
+                                       const device::Gamepad new_pad) {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool send_frame = false;
 
-  blink::WebGamepad& pad_state = pad_state_.items[index];
+  device::Gamepad& pad_state = pad_state_.items[index];
   // Update connection state.
   GamepadDelegate* delegate = gamepad_delegates_[index];
   if (new_pad.connected != pad_state.connected) {
     // New pad is disconnected.
     if (!new_pad.connected) {
       // If gamepad is disconnected now, it should be connected before, then
       // gamepad_delegate should not be null.
       DCHECK(delegate);
       delegate->OnRemoved();
       gamepad_delegates_[index] = nullptr;
@@ skipping 32 matching lines @@
       delegate->OnButton(button_id, new_button.pressed, new_button.value);
     }
   }
   if (send_frame)
     delegate->OnFrame();
 
   pad_state = new_pad;
 }
 
 }  // namespace exo