content/shell/renderer/test_runner/gamepad_controller.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/shell/renderer/test_runner/gamepad_controller.h"
   6
   7 #include "content/shell/renderer/test_runner/TestInterfaces.h"
   8 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
   9 #include "gin/arguments.h"
  10 #include "gin/handle.h"
  11 #include "gin/object_template_builder.h"
  12 #include "gin/wrappable.h"
  13 #include "third_party/WebKit/public/web/WebFrame.h"
  14 #include "third_party/WebKit/public/web/WebKit.h"
  15 #include "v8/include/v8.h"
  16
  17 using blink::WebFrame;
  18 using blink::WebGamepad;
  19 using blink::WebGamepads;
  20
  21 namespace content {
  22
  23 class GamepadControllerBindings
  24     : public gin::Wrappable<GamepadControllerBindings> {
  25  public:
  26   static gin::WrapperInfo kWrapperInfo;
  27
  28   static void Install(base::WeakPtr<GamepadController> controller,
  29                       blink::WebFrame* frame);
  30
  31  private:
  32   explicit GamepadControllerBindings(
  33       base::WeakPtr<GamepadController> controller);
  34   virtual ~GamepadControllerBindings();
  35
  36   // gin::Wrappable.
  37   virtual gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
  38       v8::Isolate* isolate) OVERRIDE;
  39
  40   void Connect(int index);
  41   void DispatchConnected(int index);
  42   void Disconnect(int index);
  43   void SetId(int index, const std::string& src);
  44   void SetButtonCount(int index, int buttons);
  45   void SetButtonData(int index, int button, double data);
  46   void SetAxisCount(int index, int axes);
  47   void SetAxisData(int index, int axis, double data);
  48
  49   base::WeakPtr<GamepadController> controller_;
  50
  51   DISALLOW_COPY_AND_ASSIGN(GamepadControllerBindings);
  52 };
  53
  54 gin::WrapperInfo GamepadControllerBindings::kWrapperInfo = {
  55     gin::kEmbedderNativeGin};
  56
  57 // static
  58 void GamepadControllerBindings::Install(
  59     base::WeakPtr<GamepadController> controller,
  60     WebFrame* frame) {
  61   v8::Isolate* isolate = blink::mainThreadIsolate();
  62   v8::HandleScope handle_scope(isolate);
  63   v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
  64   if (context.IsEmpty())
  65     return;
  66
  67   v8::Context::Scope context_scope(context);
  68
  69   gin::Handle<GamepadControllerBindings> bindings =
  70       gin::CreateHandle(isolate, new GamepadControllerBindings(controller));
  71   if (bindings.IsEmpty())
  72     return;
  73   v8::Handle<v8::Object> global = context->Global();
  74   global->Set(gin::StringToV8(isolate, "gamepadController"), bindings.ToV8());
  75 }
  76
  77 GamepadControllerBindings::GamepadControllerBindings(
  78     base::WeakPtr<GamepadController> controller)
  79     : controller_(controller) {}
  80
  81 GamepadControllerBindings::~GamepadControllerBindings() {}
  82
  83 gin::ObjectTemplateBuilder GamepadControllerBindings::GetObjectTemplateBuilder(
  84     v8::Isolate* isolate) {
  85   return gin::Wrappable<GamepadControllerBindings>::GetObjectTemplateBuilder(
  86              isolate)
  87       .SetMethod("connect", &GamepadControllerBindings::Connect)
  88       .SetMethod("dispatchConnected", &GamepadControllerBindings::DispatchConnected)
  89       .SetMethod("disconnect", &GamepadControllerBindings::Disconnect)
  90       .SetMethod("setId", &GamepadControllerBindings::SetId)
  91       .SetMethod("setButtonCount", &GamepadControllerBindings::SetButtonCount)
  92       .SetMethod("setButtonData", &GamepadControllerBindings::SetButtonData)
  93       .SetMethod("setAxisCount", &GamepadControllerBindings::SetAxisCount)
  94       .SetMethod("setAxisData", &GamepadControllerBindings::SetAxisData);
  95 }
  96
  97 void GamepadControllerBindings::Connect(int index) {
  98   if (controller_)
  99     controller_->Connect(index);
 100 }
 101
 102 void GamepadControllerBindings::DispatchConnected(int index) {
 103   if (controller_)
 104     controller_->DispatchConnected(index);
 105 }
 106
 107 void GamepadControllerBindings::Disconnect(int index) {
 108   if (controller_)
 109     controller_->Disconnect(index);
 110 }
 111
 112 void GamepadControllerBindings::SetId(int index, const std::string& src) {
 113   if (controller_)
 114     controller_->SetId(index, src);
 115 }
 116
 117 void GamepadControllerBindings::SetButtonCount(int index, int buttons) {
 118   if (controller_)
 119     controller_->SetButtonCount(index, buttons);
 120 }
 121
 122 void GamepadControllerBindings::SetButtonData(int index,
 123                                               int button,
 124                                               double data) {
 125   if (controller_)
 126     controller_->SetButtonData(index, button, data);
 127 }
 128
 129 void GamepadControllerBindings::SetAxisCount(int index, int axes) {
 130   if (controller_)
 131     controller_->SetAxisCount(index, axes);
 132 }
 133
 134 void GamepadControllerBindings::SetAxisData(int index, int axis, double data) {
 135   if (controller_)
 136     controller_->SetAxisData(index, axis, data);
 137 }
 138
 139 GamepadController::GamepadController() : delegate_(NULL), weak_factory_(this) {
 140   Reset();
 141 }
 142
 143 GamepadController::~GamepadController() {}
 144
 145 void GamepadController::Reset() {
 146   memset(&gamepads_, 0, sizeof(gamepads_));
 147 }
 148
 149 void GamepadController::Install(WebFrame* frame) {
 150   GamepadControllerBindings::Install(weak_factory_.GetWeakPtr(), frame);
 151 }
 152
 153 void GamepadController::SetDelegate(WebTestRunner::WebTestDelegate* delegate) {
 154   delegate_ = delegate;
 155 }
 156
 157 void GamepadController::Connect(int index) {
 158   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 159     return;
 160   gamepads_.items[index].connected = true;
 161   gamepads_.length = 0;
 162   for (unsigned i = 0; i < WebGamepads::itemsLengthCap; ++i) {
 163     if (gamepads_.items[i].connected)
 164       gamepads_.length = i + 1;
 165   }
 166   if (delegate_)
 167     delegate_->setGamepadData(gamepads_);
 168 }
 169
 170 void GamepadController::DispatchConnected(int index) {
 171   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 172     return;
 173   const WebGamepad& pad = gamepads_.items[index];
 174   if (pad.connected && delegate_)
 175     delegate_->didConnectGamepad(index, pad);
 176 }
 177
 178 void GamepadController::Disconnect(int index) {
 179   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 180     return;
 181   WebGamepad& pad = gamepads_.items[index];
 182   pad.connected = false;
 183   gamepads_.length = 0;
 184   for (unsigned i = 0; i < WebGamepads::itemsLengthCap; ++i) {
 185     if (gamepads_.items[i].connected)
 186       gamepads_.length = i + 1;
 187   }
 188   if (delegate_) {
 189     delegate_->setGamepadData(gamepads_);
 190     delegate_->didDisconnectGamepad(index, pad);
 191   }
 192 }
 193
 194 void GamepadController::SetId(int index, const std::string& src) {
 195   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 196     return;
 197   const char* p = src.c_str();
 198   memset(gamepads_.items[index].id, 0, sizeof(gamepads_.items[index].id));
 199   for (unsigned i = 0; *p && i < WebGamepad::idLengthCap - 1; ++i)
 200     gamepads_.items[index].id[i] = *p++;
 201   if (delegate_)
 202     delegate_->setGamepadData(gamepads_);
 203 }
 204
 205 void GamepadController::SetButtonCount(int index, int buttons) {
 206   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 207     return;
 208   if (buttons < 0 || buttons >= static_cast<int>(WebGamepad::buttonsLengthCap))
 209     return;
 210   gamepads_.items[index].buttonsLength = buttons;
 211   if (delegate_)
 212     delegate_->setGamepadData(gamepads_);
 213 }
 214
 215 void GamepadController::SetButtonData(int index, int button, double data) {
 216   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 217     return;
 218   if (button < 0 || button >= static_cast<int>(WebGamepad::buttonsLengthCap))
 219     return;
 220   gamepads_.items[index].buttons[button].value = data;
 221   gamepads_.items[index].buttons[button].pressed = data > 0.1f;
 222   if (delegate_)
 223     delegate_->setGamepadData(gamepads_);
 224 }
 225
 226 void GamepadController::SetAxisCount(int index, int axes) {
 227   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 228     return;
 229   if (axes < 0 || axes >= static_cast<int>(WebGamepad::axesLengthCap))
 230     return;
 231   gamepads_.items[index].axesLength = axes;
 232   if (delegate_)
 233     delegate_->setGamepadData(gamepads_);
 234 }
 235
 236 void GamepadController::SetAxisData(int index, int axis, double data) {
 237   if (index < 0 || index >= static_cast<int>(WebGamepads::itemsLengthCap))
 238     return;
 239   if (axis < 0 || axis >= static_cast<int>(WebGamepad::axesLengthCap))
 240     return;
 241   gamepads_.items[index].axes[axis] = data;
 242   if (delegate_)
 243     delegate_->setGamepadData(gamepads_);
 244 }
 245
 246 }  // namespace content