OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <cmath> | 5 #include <cmath> |
6 #include <set> | 6 #include <set> |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
11 #include "base/message_loop.h" | 11 #include "base/message_loop.h" |
| 12 #include "base/synchronization/lock.h" |
12 #include "base/task.h" | 13 #include "base/task.h" |
13 #include "base/threading/thread.h" | 14 #include "base/threading/thread.h" |
14 #include "base/threading/thread_restrictions.h" | 15 #include "base/threading/thread_restrictions.h" |
15 #include "content/public/browser/browser_thread.h" | 16 #include "content/public/browser/browser_thread.h" |
16 #include "content/browser/gamepad/gamepad_provider.h" | 17 #include "content/browser/gamepad/gamepad_provider.h" |
17 #include "content/browser/gamepad/data_fetcher.h" | 18 #include "content/browser/gamepad/data_fetcher.h" |
18 #include "content/common/gamepad_messages.h" | 19 #include "content/common/gamepad_messages.h" |
19 | 20 |
20 #if defined(OS_WIN) | 21 #if defined(OS_WIN) |
21 #include "content/browser/gamepad/data_fetcher_win.h" | 22 #include "content/browser/gamepad/data_fetcher_win.h" |
22 #endif | 23 #endif |
23 | 24 |
24 namespace content { | 25 namespace content { |
25 | 26 |
26 GamepadProvider* GamepadProvider::instance_ = NULL; | |
27 | |
28 // Define the default data fetcher that GamepadProvider will use if none is | 27 // Define the default data fetcher that GamepadProvider will use if none is |
29 // supplied. (GamepadPlatformDataFetcher). | 28 // supplied. (GamepadPlatformDataFetcher). |
30 #if defined(OS_WIN) | 29 #if defined(OS_WIN) |
31 | 30 |
32 typedef GamepadDataFetcherWindows GamepadPlatformDataFetcher; | 31 typedef GamepadDataFetcherWindows GamepadPlatformDataFetcher; |
33 | 32 |
34 #else | 33 #else |
35 | 34 |
36 class GamepadEmptyDataFetcher : public GamepadDataFetcher { | 35 class GamepadEmptyDataFetcher : public GamepadDataFetcher { |
37 public: | 36 public: |
38 void GetGamepadData(WebKit::WebGamepads* pads, bool) { | 37 void GetGamepadData(WebKit::WebGamepads* pads, bool) { |
39 pads->length = 0; | 38 pads->length = 0; |
40 } | 39 } |
41 }; | 40 }; |
42 typedef GamepadEmptyDataFetcher GamepadPlatformDataFetcher; | 41 typedef GamepadEmptyDataFetcher GamepadPlatformDataFetcher; |
43 | 42 |
44 #endif | 43 #endif |
45 | 44 |
46 GamepadProvider::GamepadProvider(GamepadDataFetcher* fetcher) | 45 GamepadProvider::GamepadProvider(GamepadDataFetcher* fetcher) |
47 : creator_loop_(MessageLoop::current()->message_loop_proxy()), | 46 : is_paused_(false), |
| 47 devices_changed_(true), |
| 48 creator_loop_(MessageLoop::current()->message_loop_proxy()), |
48 provided_fetcher_(fetcher), | 49 provided_fetcher_(fetcher), |
49 devices_changed_(true), | |
50 ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { | 50 ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { |
51 size_t data_size = sizeof(GamepadHardwareBuffer); | 51 size_t data_size = sizeof(GamepadHardwareBuffer); |
52 base::SystemMonitor* monitor = base::SystemMonitor::Get(); | 52 base::SystemMonitor* monitor = base::SystemMonitor::Get(); |
53 if (monitor) | 53 if (monitor) |
54 monitor->AddDevicesChangedObserver(this); | 54 monitor->AddDevicesChangedObserver(this); |
55 gamepad_shared_memory_.CreateAndMapAnonymous(data_size); | 55 gamepad_shared_memory_.CreateAndMapAnonymous(data_size); |
56 GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer(); | 56 GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer(); |
57 memset(hwbuf, 0, sizeof(GamepadHardwareBuffer)); | 57 memset(hwbuf, 0, sizeof(GamepadHardwareBuffer)); |
| 58 |
| 59 DCHECK(MessageLoop::current()->message_loop_proxy() == creator_loop_); |
| 60 |
| 61 polling_thread_.reset(new base::Thread("Gamepad polling thread")); |
| 62 if (!polling_thread_->Start()) { |
| 63 LOG(ERROR) << "Failed to start gamepad polling thread"; |
| 64 polling_thread_.reset(); |
| 65 return; |
| 66 } |
| 67 |
| 68 MessageLoop* polling_loop = polling_thread_->message_loop(); |
| 69 polling_loop->PostTask( |
| 70 FROM_HERE, |
| 71 base::Bind(&GamepadProvider::DoInitializePollingThread, this)); |
58 } | 72 } |
59 | 73 |
60 GamepadProvider::~GamepadProvider() { | 74 GamepadProvider::~GamepadProvider() { |
61 base::SystemMonitor* monitor = base::SystemMonitor::Get(); | 75 base::SystemMonitor* monitor = base::SystemMonitor::Get(); |
62 if (monitor) | 76 if (monitor) |
63 monitor->RemoveDevicesChangedObserver(this); | 77 monitor->RemoveDevicesChangedObserver(this); |
64 Stop(); | 78 |
| 79 polling_thread_.reset(); |
| 80 data_fetcher_.reset(); |
65 } | 81 } |
66 | 82 |
67 base::SharedMemoryHandle GamepadProvider::GetRendererSharedMemoryHandle( | 83 base::SharedMemoryHandle GamepadProvider::GetRendererSharedMemoryHandle( |
68 base::ProcessHandle process) { | 84 base::ProcessHandle process) { |
69 base::SharedMemoryHandle renderer_handle; | 85 base::SharedMemoryHandle renderer_handle; |
70 gamepad_shared_memory_.ShareToProcess(process, &renderer_handle); | 86 gamepad_shared_memory_.ShareToProcess(process, &renderer_handle); |
71 return renderer_handle; | 87 return renderer_handle; |
72 } | 88 } |
73 | 89 |
| 90 void GamepadProvider::Pause() { |
| 91 base::AutoLock lock(is_paused_lock_); |
| 92 is_paused_ = true; |
| 93 } |
| 94 |
| 95 void GamepadProvider::Resume() { |
| 96 base::AutoLock lock(is_paused_lock_); |
| 97 |
| 98 if (!is_paused_) |
| 99 return; |
| 100 |
| 101 is_paused_ = false; |
| 102 MessageLoop* polling_loop = polling_thread_->message_loop(); |
| 103 polling_loop->PostTask( |
| 104 FROM_HERE, |
| 105 base::Bind(&GamepadProvider::ScheduleDoPoll, this)); |
| 106 } |
| 107 |
74 void GamepadProvider::OnDevicesChanged() { | 108 void GamepadProvider::OnDevicesChanged() { |
| 109 base::AutoLock lock(devices_changed_lock_); |
75 devices_changed_ = true; | 110 devices_changed_ = true; |
76 } | 111 } |
77 | 112 |
78 void GamepadProvider::Start() { | |
79 DCHECK(MessageLoop::current()->message_loop_proxy() == creator_loop_); | |
80 | |
81 if (polling_thread_.get()) | |
82 return; | |
83 | |
84 polling_thread_.reset(new base::Thread("Gamepad polling thread")); | |
85 if (!polling_thread_->Start()) { | |
86 LOG(ERROR) << "Failed to start gamepad polling thread"; | |
87 polling_thread_.reset(); | |
88 return; | |
89 } | |
90 | |
91 MessageLoop* polling_loop = polling_thread_->message_loop(); | |
92 polling_loop->PostTask( | |
93 FROM_HERE, | |
94 base::Bind(&GamepadProvider::DoInitializePollingThread, this)); | |
95 } | |
96 | |
97 void GamepadProvider::Stop() { | |
98 DCHECK(MessageLoop::current()->message_loop_proxy() == creator_loop_); | |
99 | |
100 polling_thread_.reset(); | |
101 data_fetcher_.reset(); | |
102 } | |
103 | |
104 void GamepadProvider::DoInitializePollingThread() { | 113 void GamepadProvider::DoInitializePollingThread() { |
105 DCHECK(MessageLoop::current() == polling_thread_->message_loop()); | 114 DCHECK(MessageLoop::current() == polling_thread_->message_loop()); |
106 | 115 |
107 if (!provided_fetcher_.get()) | 116 if (!provided_fetcher_.get()) |
108 provided_fetcher_.reset(new GamepadPlatformDataFetcher); | 117 provided_fetcher_.reset(new GamepadPlatformDataFetcher); |
109 | 118 |
110 // Pass ownership of fetcher to provider_. | 119 // Pass ownership of fetcher to provider_. |
111 data_fetcher_.swap(provided_fetcher_); | 120 data_fetcher_.swap(provided_fetcher_); |
112 | 121 |
113 // Start polling. | 122 // Start polling. |
114 ScheduleDoPoll(); | 123 ScheduleDoPoll(); |
115 } | 124 } |
116 | 125 |
117 void GamepadProvider::DoPoll() { | 126 void GamepadProvider::DoPoll() { |
118 DCHECK(MessageLoop::current() == polling_thread_->message_loop()); | 127 DCHECK(MessageLoop::current() == polling_thread_->message_loop()); |
119 GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer(); | 128 GamepadHardwareBuffer* hwbuf = SharedMemoryAsHardwareBuffer(); |
120 | 129 |
121 ANNOTATE_BENIGN_RACE_SIZED( | 130 ANNOTATE_BENIGN_RACE_SIZED( |
122 &hwbuf->buffer, | 131 &hwbuf->buffer, |
123 sizeof(WebKit::WebGamepads), | 132 sizeof(WebKit::WebGamepads), |
124 "Racey reads are discarded"); | 133 "Racey reads are discarded"); |
125 | 134 |
| 135 devices_changed_lock_.Acquire(); |
| 136 |
126 // Acquire the SeqLock. There is only ever one writer to this data. | 137 // Acquire the SeqLock. There is only ever one writer to this data. |
127 // See gamepad_hardware_buffer.h. | 138 // See gamepad_hardware_buffer.h. |
128 hwbuf->sequence.WriteBegin(); | 139 hwbuf->sequence.WriteBegin(); |
129 data_fetcher_->GetGamepadData(&hwbuf->buffer, devices_changed_); | 140 data_fetcher_->GetGamepadData(&hwbuf->buffer, devices_changed_); |
130 hwbuf->sequence.WriteEnd(); | 141 hwbuf->sequence.WriteEnd(); |
131 devices_changed_ = false; | 142 devices_changed_ = false; |
| 143 |
| 144 devices_changed_lock_.Release(); |
| 145 |
132 // Schedule our next interval of polling. | 146 // Schedule our next interval of polling. |
133 ScheduleDoPoll(); | 147 ScheduleDoPoll(); |
134 } | 148 } |
135 | 149 |
136 void GamepadProvider::ScheduleDoPoll() { | 150 void GamepadProvider::ScheduleDoPoll() { |
137 DCHECK(MessageLoop::current() == polling_thread_->message_loop()); | 151 DCHECK(MessageLoop::current() == polling_thread_->message_loop()); |
| 152 base::AutoLock lock(is_paused_lock_); |
| 153 |
| 154 if (is_paused_) |
| 155 return; |
138 | 156 |
139 MessageLoop::current()->PostDelayedTask( | 157 MessageLoop::current()->PostDelayedTask( |
140 FROM_HERE, | 158 FROM_HERE, |
141 base::Bind(&GamepadProvider::DoPoll, weak_factory_.GetWeakPtr()), | 159 base::Bind(&GamepadProvider::DoPoll, weak_factory_.GetWeakPtr()), |
142 kDesiredSamplingIntervalMs); | 160 kDesiredSamplingIntervalMs); |
143 } | 161 } |
144 | 162 |
145 GamepadHardwareBuffer* GamepadProvider::SharedMemoryAsHardwareBuffer() { | 163 GamepadHardwareBuffer* GamepadProvider::SharedMemoryAsHardwareBuffer() { |
146 void* mem = gamepad_shared_memory_.memory(); | 164 void* mem = gamepad_shared_memory_.memory(); |
147 DCHECK(mem); | 165 DCHECK(mem); |
148 return static_cast<GamepadHardwareBuffer*>(mem); | 166 return static_cast<GamepadHardwareBuffer*>(mem); |
149 } | 167 } |
150 | 168 |
151 } // namespace content | 169 } // namespace content |
OLD | NEW |