src/content/browser/gamepad/gamepad_provider.cc

   1 // Copyright (c) 2012 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 <cmath>
   6 #include <set>
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/message_loop/message_loop_proxy.h"
  13 #include "base/threading/thread.h"
  14 #include "base/threading/thread_restrictions.h"
  15 #include "content/browser/gamepad/gamepad_data_fetcher.h"
  16 #include "content/browser/gamepad/gamepad_platform_data_fetcher.h"
  17 #include "content/browser/gamepad/gamepad_provider.h"
  18 #include "content/browser/gamepad/gamepad_service.h"
  19 #include "content/common/gamepad_hardware_buffer.h"
  20 #include "content/common/gamepad_messages.h"
  21 #include "content/common/gamepad_user_gesture.h"
  22 #include "content/public/browser/browser_thread.h"
  23
  24 using blink::WebGamepad;
  25 using blink::WebGamepads;
  26
  27 namespace content {
  28
  29 GamepadProvider::ClosureAndThread::ClosureAndThread(
  30     const base::Closure& c,
  31     const scoped_refptr<base::MessageLoopProxy>& m)
  32     : closure(c),
  33       message_loop(m) {
  34 }
  35
  36 GamepadProvider::ClosureAndThread::~ClosureAndThread() {
  37 }
  38
  39 GamepadProvider::GamepadProvider()
  40     : is_paused_(true),
  41       have_scheduled_do_poll_(false),
  42       devices_changed_(true),
  43       ever_had_user_gesture_(false) {
  44   Initialize(scoped_ptr<GamepadDataFetcher>());
  45 }
  46
  47 GamepadProvider::GamepadProvider(scoped_ptr<GamepadDataFetcher> fetcher)
  48     : is_paused_(true),
  49       have_scheduled_do_poll_(false),
  50       devices_changed_(true),
  51       ever_had_user_gesture_(false) {
  52   Initialize(fetcher.Pass());
  53 }
  54
  55 GamepadProvider::~GamepadProvider() {
  56   base::SystemMonitor* monitor = base::SystemMonitor::Get();
  57   if (monitor)
  58     monitor->RemoveDevicesChangedObserver(this);
  59
  60   // Use Stop() to join the polling thread, as there may be pending callbacks
  61   // which dereference |polling_thread_|.
  62   polling_thread_->Stop();
  63   data_fetcher_.reset();
  64 }
  65
  66 base::SharedMemoryHandle GamepadProvider::GetSharedMemoryHandleForProcess(
  67     base::ProcessHandle process) {
  68   base::SharedMemoryHandle renderer_handle;
  69   gamepad_shared_memory_.ShareToProcess(process, &renderer_handle);
  70   return renderer_handle;
  71 }
  72
  73 void GamepadProvider::GetCurrentGamepadData(WebGamepads* data) {
  74   const WebGamepads& pads = SharedMemoryAsHardwareBuffer()->buffer;
  75   base::AutoLock lock(shared_memory_lock_);
  76   *data = pads;
  77 }
  78
  79 void GamepadProvider::Pause() {
  80   {
  81     base::AutoLock lock(is_paused_lock_);
  82     is_paused_ = true;
  83   }
  84   base::MessageLoop* polling_loop = polling_thread_->message_loop();
  85   polling_loop->PostTask(
  86       FROM_HERE,
  87       base::Bind(&GamepadProvider::SendPauseHint, Unretained(this), true));
  88 }
  89
  90 void GamepadProvider::Resume() {
  91   {
  92     base::AutoLock lock(is_paused_lock_);
  93     if (!is_paused_)
  94         return;
  95     is_paused_ = false;
  96   }
  97
  98   base::MessageLoop* polling_loop = polling_thread_->message_loop();
  99   polling_loop->PostTask(
 100       FROM_HERE,
 101       base::Bind(&GamepadProvider::SendPauseHint, Unretained(this), false));
 102   polling_loop->PostTask(
 103       FROM_HERE,
 104       base::Bind(&GamepadProvider::ScheduleDoPoll, Unretained(this)));
 105 }
 106
 107 void GamepadProvider::RegisterForUserGesture(const base::Closure& closure) {
 108   base::AutoLock lock(user_gesture_lock_);
 109   user_gesture_observers_.push_back(ClosureAndThread(
 110       closure, base::MessageLoop::current()->message_loop_proxy()));
 111 }
 112
 113 void GamepadProvider::OnDevicesChanged(base::SystemMonitor::DeviceType type) {
 114   base::AutoLock lock(devices_changed_lock_);
 115   devices_changed_ = true;
 116 }
 117
 118 void GamepadProvider::Initialize(scoped_ptr<GamepadDataFetcher> fetcher) {
 119   size_t data_size = sizeof(GamepadHardwareBuffer);
 120   base::SystemMonitor* monitor = base::SystemMonitor::Get();
 121   if (monitor)
 122     monitor->AddDevicesChangedObserver(this);
 123   bool res = gamepad_shared_memory_.CreateAndMapAnonymous(data_size);
 124   CHECK(res);
 125   GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer();
 126   memset(hwbuf, 0, sizeof(GamepadHardwareBuffer));
 127   pad_states_.reset(new PadState[WebGamepads::itemsLengthCap]);
 128
 129   polling_thread_.reset(new base::Thread("Gamepad polling thread"));
 130 #if defined(OS_LINUX)
 131   // On Linux, the data fetcher needs to watch file descriptors, so the message
 132   // loop needs to be a libevent loop.
 133   const base::MessageLoop::Type kMessageLoopType = base::MessageLoop::TYPE_IO;
 134 #else
 135   // On Mac, the data fetcher uses IOKit which depends on CFRunLoop, so the
 136   // message loop needs to be a UI-type loop. On Windows it must be a UI loop
 137   // to properly pump the MessageWindow that captures device state.
 138   const base::MessageLoop::Type kMessageLoopType = base::MessageLoop::TYPE_UI;
 139 #endif
 140   polling_thread_->StartWithOptions(base::Thread::Options(kMessageLoopType, 0));
 141
 142   polling_thread_->message_loop()->PostTask(
 143       FROM_HERE,
 144       base::Bind(&GamepadProvider::DoInitializePollingThread,
 145                  base::Unretained(this),
 146                  base::Passed(&fetcher)));
 147 }
 148
 149 void GamepadProvider::DoInitializePollingThread(
 150     scoped_ptr<GamepadDataFetcher> fetcher) {
 151   DCHECK(base::MessageLoop::current() == polling_thread_->message_loop());
 152   DCHECK(!data_fetcher_.get());  // Should only initialize once.
 153
 154   if (!fetcher)
 155     fetcher.reset(new GamepadPlatformDataFetcher);
 156   data_fetcher_ = fetcher.Pass();
 157 }
 158
 159 void GamepadProvider::SendPauseHint(bool paused) {
 160   DCHECK(base::MessageLoop::current() == polling_thread_->message_loop());
 161   if (data_fetcher_)
 162     data_fetcher_->PauseHint(paused);
 163 }
 164
 165 bool GamepadProvider::PadState::Match(const WebGamepad& pad) const {
 166   return connected_ == pad.connected &&
 167          axes_length_ == pad.axesLength &&
 168          buttons_length_ == pad.buttonsLength &&
 169          memcmp(id_, pad.id, arraysize(id_)) == 0 &&
 170          memcmp(mapping_, pad.mapping, arraysize(mapping_)) == 0;
 171 }
 172
 173 void GamepadProvider::PadState::SetPad(const WebGamepad& pad) {
 174   DCHECK(pad.connected);
 175   connected_ = true;
 176   axes_length_ = pad.axesLength;
 177   buttons_length_ = pad.buttonsLength;
 178   memcpy(id_, pad.id, arraysize(id_));
 179   memcpy(mapping_, pad.mapping, arraysize(mapping_));
 180 }
 181
 182 void GamepadProvider::PadState::SetDisconnected() {
 183   connected_ = false;
 184   axes_length_ = 0;
 185   buttons_length_ = 0;
 186   memset(id_, 0, arraysize(id_));
 187   memset(mapping_, 0, arraysize(mapping_));
 188 }
 189
 190 void GamepadProvider::PadState::AsWebGamepad(WebGamepad* pad) {
 191   pad->connected = connected_;
 192   pad->axesLength = axes_length_;
 193   pad->buttonsLength = buttons_length_;
 194   memcpy(pad->id, id_, arraysize(id_));
 195   memcpy(pad->mapping, mapping_, arraysize(mapping_));
 196   memset(pad->axes, 0, arraysize(pad->axes));
 197   memset(pad->buttons, 0, arraysize(pad->buttons));
 198 }
 199
 200 void GamepadProvider::DoPoll() {
 201   DCHECK(base::MessageLoop::current() == polling_thread_->message_loop());
 202   DCHECK(have_scheduled_do_poll_);
 203   have_scheduled_do_poll_ = false;
 204
 205   bool changed;
 206   GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer();
 207
 208   ANNOTATE_BENIGN_RACE_SIZED(
 209       &hwbuf->buffer,
 210       sizeof(WebGamepads),
 211       "Racey reads are discarded");
 212
 213   {
 214     base::AutoLock lock(devices_changed_lock_);
 215     changed = devices_changed_;
 216     devices_changed_ = false;
 217   }
 218
 219   {
 220     base::AutoLock lock(shared_memory_lock_);
 221
 222     // Acquire the SeqLock. There is only ever one writer to this data.
 223     // See gamepad_hardware_buffer.h.
 224     hwbuf->sequence.WriteBegin();
 225     data_fetcher_->GetGamepadData(&hwbuf->buffer, changed);
 226     hwbuf->sequence.WriteEnd();
 227   }
 228
 229   CheckForUserGesture();
 230
 231   if (ever_had_user_gesture_) {
 232     for (unsigned i = 0; i < WebGamepads::itemsLengthCap; ++i) {
 233       WebGamepad& pad = hwbuf->buffer.items[i];
 234       PadState& state = pad_states_.get()[i];
 235       if (pad.connected && !state.connected()) {
 236         OnGamepadConnectionChange(true, i, pad);
 237       } else if (!pad.connected && state.connected()) {
 238         OnGamepadConnectionChange(false, i, pad);
 239       } else if (pad.connected && state.connected() && !state.Match(pad)) {
 240         WebGamepad old_pad;
 241         state.AsWebGamepad(&old_pad);
 242         OnGamepadConnectionChange(false, i, old_pad);
 243         OnGamepadConnectionChange(true, i, pad);
 244       }
 245     }
 246   }
 247
 248   // Schedule our next interval of polling.
 249   ScheduleDoPoll();
 250 }
 251
 252 void GamepadProvider::ScheduleDoPoll() {
 253   DCHECK(base::MessageLoop::current() == polling_thread_->message_loop());
 254   if (have_scheduled_do_poll_)
 255     return;
 256
 257   {
 258     base::AutoLock lock(is_paused_lock_);
 259     if (is_paused_)
 260       return;
 261   }
 262
 263   base::MessageLoop::current()->PostDelayedTask(
 264       FROM_HERE,
 265       base::Bind(&GamepadProvider::DoPoll, Unretained(this)),
 266       base::TimeDelta::FromMilliseconds(kDesiredSamplingIntervalMs));
 267   have_scheduled_do_poll_ = true;
 268 }
 269
 270 void GamepadProvider::OnGamepadConnectionChange(
 271     bool connected, int index, const WebGamepad& pad) {
 272   PadState& state = pad_states_.get()[index];
 273   if (connected)
 274     state.SetPad(pad);
 275   else
 276     state.SetDisconnected();
 277
 278   BrowserThread::PostTask(
 279       BrowserThread::IO,
 280       FROM_HERE,
 281       base::Bind(&GamepadProvider::DispatchGamepadConnectionChange,
 282                  base::Unretained(this),
 283                  connected,
 284                  index,
 285                  pad));
 286 }
 287
 288 void GamepadProvider::DispatchGamepadConnectionChange(
 289     bool connected, int index, const WebGamepad& pad) {
 290   if (connected)
 291     GamepadService::GetInstance()->OnGamepadConnected(index, pad);
 292   else
 293     GamepadService::GetInstance()->OnGamepadDisconnected(index, pad);
 294 }
 295
 296 GamepadHardwareBuffer* GamepadProvider::SharedMemoryAsHardwareBuffer() {
 297   void* mem = gamepad_shared_memory_.memory();
 298   CHECK(mem);
 299   return static_cast<GamepadHardwareBuffer*>(mem);
 300 }
 301
 302 void GamepadProvider::CheckForUserGesture() {
 303   base::AutoLock lock(user_gesture_lock_);
 304   if (user_gesture_observers_.empty() && ever_had_user_gesture_)
 305     return;
 306
 307   if (GamepadsHaveUserGesture(SharedMemoryAsHardwareBuffer()->buffer)) {
 308     ever_had_user_gesture_ = true;
 309     for (size_t i = 0; i < user_gesture_observers_.size(); i++) {
 310       user_gesture_observers_[i].message_loop->PostTask(FROM_HERE,
 311           user_gesture_observers_[i].closure);
 312     }
 313     user_gesture_observers_.clear();
 314   }
 315 }
 316
 317 }  // namespace content