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

device/gamepad/gamepad_pad_state_provider.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 "device/gamepad/gamepad_pad_state_provider.h"
 
 #include <cmath>
 
 #include "device/gamepad/gamepad_data_fetcher.h"
-#include "third_party/WebKit/public/platform/WebGamepads.h"
-
-using blink::WebGamepad;
-using blink::WebGamepads;
+#include "device/gamepad/public/cpp/gamepads.h"
 
 namespace device {
 
 namespace {
 
 const float kMinAxisResetValue = 0.1f;
 
 }  // namespace
 
 GamepadPadStateProvider::GamepadPadStateProvider() {
-  pad_states_.reset(new PadState[WebGamepads::kItemsLengthCap]);
+  pad_states_.reset(new PadState[Gamepads::kItemsLengthCap]);
 
-  for (unsigned i = 0; i < WebGamepads::kItemsLengthCap; ++i)
+  for (unsigned i = 0; i < Gamepads::kItemsLengthCap; ++i)
     ClearPadState(pad_states_.get()[i]);
 }
 
 GamepadPadStateProvider::~GamepadPadStateProvider() {}
 
 PadState* GamepadPadStateProvider::GetPadState(GamepadSource source,
                                                int source_id) {
   // Check to see if the device already has a reserved slot
   PadState* empty_slot = nullptr;
-  for (size_t i = 0; i < WebGamepads::kItemsLengthCap; ++i) {
+  for (size_t i = 0; i < Gamepads::kItemsLengthCap; ++i) {
     PadState& state = pad_states_.get()[i];
     if (state.source == source && state.source_id == source_id) {
       // Retrieving the pad state marks this gamepad as active.
       state.active_state = GAMEPAD_ACTIVE;
       return &state;
     }
     if (!empty_slot && state.source == GAMEPAD_SOURCE_NONE)
       empty_slot = &state;
   }
   if (empty_slot) {
     empty_slot->source = source;
     empty_slot->source_id = source_id;
     empty_slot->active_state = GAMEPAD_NEWLY_ACTIVE;
   }
   return empty_slot;
 }
 
 void GamepadPadStateProvider::ClearPadState(PadState& state) {
   memset(&state, 0, sizeof(PadState));
 }
 
 void GamepadPadStateProvider::InitializeDataFetcher(
     GamepadDataFetcher* fetcher) {
   fetcher->InitializeProvider(this);
 }
 
 void GamepadPadStateProvider::MapAndSanitizeGamepadData(PadState* pad_state,
-                                                        WebGamepad* pad,
+                                                        Gamepad* pad,
                                                         bool sanitize) {
   DCHECK(pad_state);
   DCHECK(pad);
 
   if (!pad_state->data.connected) {
-    memset(pad, 0, sizeof(WebGamepad));
+    memset(pad, 0, sizeof(Gamepad));
     return;
   }
 
   // Copy the current state to the output buffer, using the mapping
   // function, if there is one available.
   if (pad_state->mapper)
     pad_state->mapper(pad_state->data, pad);
   else
     *pad = pad_state->data;
 
@@ skipping 36 matching lines @@
         } else {
           pad->buttons[button].pressed = false;
           pad->buttons[button].value = 0.0f;
         }
       }
     }
   }
 }
 
 }  // namespace device