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.h"
  12 #include "base/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_provider.h"
  17 #include "content/browser/gamepad/gamepad_platform_data_fetcher.h"
  18 #include "content/common/gamepad_hardware_buffer.h"
  19 #include "content/common/gamepad_messages.h"
  20 #include "content/common/gamepad_user_gesture.h"
  21 #include "content/public/browser/browser_thread.h"
  22
  23 namespace content {
  24
  25 GamepadProvider::ClosureAndThread::ClosureAndThread(
  26     const base::Closure& c,
  27     const scoped_refptr<base::MessageLoopProxy>& m)
  28     : closure(c),
  29       message_loop(m) {
  30 }
  31
  32 GamepadProvider::ClosureAndThread::~ClosureAndThread() {
  33 }
  34
  35 GamepadProvider::GamepadProvider()
  36     : is_paused_(true),
  37       have_scheduled_do_poll_(false),
  38       devices_changed_(true) {
  39   Initialize(scoped_ptr<GamepadDataFetcher>());
  40 }
  41
  42 GamepadProvider::GamepadProvider(scoped_ptr<GamepadDataFetcher> fetcher)
  43     : is_paused_(true),
  44       have_scheduled_do_poll_(false),
  45       devices_changed_(true) {
  46   Initialize(fetcher.Pass());
  47 }
  48
  49 GamepadProvider::~GamepadProvider() {
  50   base::SystemMonitor* monitor = base::SystemMonitor::Get();
  51   if (monitor)
  52     monitor->RemoveDevicesChangedObserver(this);
  53
  54   polling_thread_.reset();
  55   data_fetcher_.reset();
  56 }
  57
  58 base::SharedMemoryHandle GamepadProvider::GetSharedMemoryHandleForProcess(
  59     base::ProcessHandle process) {
  60   base::SharedMemoryHandle renderer_handle;
  61   gamepad_shared_memory_.ShareToProcess(process, &renderer_handle);
  62   return renderer_handle;
  63 }
  64
  65 void GamepadProvider::Pause() {
  66   {
  67     base::AutoLock lock(is_paused_lock_);
  68     is_paused_ = true;
  69   }
  70   MessageLoop* polling_loop = polling_thread_->message_loop();
  71   polling_loop->PostTask(
  72       FROM_HERE,
  73       base::Bind(&GamepadProvider::SendPauseHint, Unretained(this), true));
  74 }
  75
  76 void GamepadProvider::Resume() {
  77   {
  78     base::AutoLock lock(is_paused_lock_);
  79     if (!is_paused_)
  80         return;
  81     is_paused_ = false;
  82   }
  83
  84   MessageLoop* polling_loop = polling_thread_->message_loop();
  85   polling_loop->PostTask(
  86       FROM_HERE,
  87       base::Bind(&GamepadProvider::SendPauseHint, Unretained(this), false));
  88   polling_loop->PostTask(
  89       FROM_HERE,
  90       base::Bind(&GamepadProvider::ScheduleDoPoll, Unretained(this)));
  91 }
  92
  93 void GamepadProvider::RegisterForUserGesture(const base::Closure& closure) {
  94   base::AutoLock lock(user_gesture_lock_);
  95   user_gesture_observers_.push_back(
  96       ClosureAndThread(closure, MessageLoop::current()->message_loop_proxy()));
  97 }
  98
  99 void GamepadProvider::OnDevicesChanged(base::SystemMonitor::DeviceType type) {
 100   base::AutoLock lock(devices_changed_lock_);
 101   devices_changed_ = true;
 102 }
 103
 104 void GamepadProvider::Initialize(scoped_ptr<GamepadDataFetcher> fetcher) {
 105   size_t data_size = sizeof(GamepadHardwareBuffer);
 106   base::SystemMonitor* monitor = base::SystemMonitor::Get();
 107   if (monitor)
 108     monitor->AddDevicesChangedObserver(this);
 109   bool res = gamepad_shared_memory_.CreateAndMapAnonymous(data_size);
 110   CHECK(res);
 111   GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer();
 112   memset(hwbuf, 0, sizeof(GamepadHardwareBuffer));
 113
 114   polling_thread_.reset(new base::Thread("Gamepad polling thread"));
 115   polling_thread_->StartWithOptions(
 116       base::Thread::Options(MessageLoop::TYPE_IO, 0));
 117
 118   polling_thread_->message_loop()->PostTask(
 119       FROM_HERE,
 120       base::Bind(&GamepadProvider::DoInitializePollingThread,
 121                  base::Unretained(this),
 122                  base::Passed(&fetcher)));
 123 }
 124
 125 void GamepadProvider::DoInitializePollingThread(
 126     scoped_ptr<GamepadDataFetcher> fetcher) {
 127   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 128   DCHECK(!data_fetcher_.get());  // Should only initialize once.
 129
 130   if (!fetcher.get())
 131     fetcher.reset(new GamepadPlatformDataFetcher);
 132   data_fetcher_ = fetcher.Pass();
 133 }
 134
 135 void GamepadProvider::SendPauseHint(bool paused) {
 136   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 137   if (data_fetcher_.get())
 138     data_fetcher_->PauseHint(paused);
 139 }
 140
 141 void GamepadProvider::DoPoll() {
 142   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 143   DCHECK(have_scheduled_do_poll_);
 144   have_scheduled_do_poll_ = false;
 145
 146   bool changed;
 147   GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer();
 148
 149   ANNOTATE_BENIGN_RACE_SIZED(
 150       &hwbuf->buffer,
 151       sizeof(WebKit::WebGamepads),
 152       "Racey reads are discarded");
 153
 154   {
 155     base::AutoLock lock(devices_changed_lock_);
 156     changed = devices_changed_;
 157     devices_changed_ = false;
 158   }
 159
 160   // Acquire the SeqLock. There is only ever one writer to this data.
 161   // See gamepad_hardware_buffer.h.
 162   hwbuf->sequence.WriteBegin();
 163   data_fetcher_->GetGamepadData(&hwbuf->buffer, changed);
 164   hwbuf->sequence.WriteEnd();
 165
 166   CheckForUserGesture();
 167
 168   // Schedule our next interval of polling.
 169   ScheduleDoPoll();
 170 }
 171
 172 void GamepadProvider::ScheduleDoPoll() {
 173   DCHECK(MessageLoop::current() == polling_thread_->message_loop());
 174   if (have_scheduled_do_poll_)
 175     return;
 176
 177   {
 178     base::AutoLock lock(is_paused_lock_);
 179     if (is_paused_)
 180       return;
 181   }
 182
 183   MessageLoop::current()->PostDelayedTask(
 184       FROM_HERE,
 185       base::Bind(&GamepadProvider::DoPoll, Unretained(this)),
 186       base::TimeDelta::FromMilliseconds(kDesiredSamplingIntervalMs));
 187   have_scheduled_do_poll_ = true;
 188 }
 189
 190 GamepadHardwareBuffer* GamepadProvider::SharedMemoryAsHardwareBuffer() {
 191   void* mem = gamepad_shared_memory_.memory();
 192   CHECK(mem);
 193   return static_cast<GamepadHardwareBuffer*>(mem);
 194 }
 195
 196 void GamepadProvider::CheckForUserGesture() {
 197   base::AutoLock lock(user_gesture_lock_);
 198   if (user_gesture_observers_.empty())
 199     return;  // Don't need to check if nobody is listening.
 200
 201   if (GamepadsHaveUserGesture(SharedMemoryAsHardwareBuffer()->buffer)) {
 202     for (size_t i = 0; i < user_gesture_observers_.size(); i++) {
 203       user_gesture_observers_[i].message_loop->PostTask(FROM_HERE,
 204           user_gesture_observers_[i].closure);
 205     }
 206     user_gesture_observers_.clear();
 207   }
 208 }
 209
 210 }  // namespace content