OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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 "content/browser/gamepad/gamepad_service.h" | 5 #include "content/browser/gamepad/gamepad_service.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
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/memory/singleton.h" | 11 #include "base/memory/singleton.h" |
12 #include "content/browser/gamepad/gamepad_consumer.h" | 12 #include "content/browser/gamepad/gamepad_shared_buffer_impl.h" |
13 #include "content/browser/gamepad/gamepad_data_fetcher.h" | |
14 #include "content/browser/gamepad/gamepad_provider.h" | |
15 #include "content/public/browser/browser_thread.h" | 13 #include "content/public/browser/browser_thread.h" |
16 #include "content/public/browser/render_process_host.h" | 14 #include "content/public/browser/render_process_host.h" |
15 #include "device/gamepad/gamepad_consumer.h" | |
16 #include "device/gamepad/gamepad_data_fetcher.h" | |
17 #include "device/gamepad/gamepad_provider.h" | |
17 | 18 |
18 namespace content { | 19 namespace content { |
19 | 20 |
20 namespace { | 21 namespace { |
21 GamepadService* g_gamepad_service = 0; | 22 GamepadService* g_gamepad_service = 0; |
22 } | 23 } |
23 | 24 |
24 GamepadService::GamepadService() | 25 GamepadService::GamepadService() |
25 : num_active_consumers_(0), | 26 : num_active_consumers_(0), |
26 gesture_callback_pending_(false) { | 27 gesture_callback_pending_(false) { |
27 SetInstance(this); | 28 SetInstance(this); |
28 } | 29 } |
29 | 30 |
30 GamepadService::GamepadService(std::unique_ptr<GamepadDataFetcher> fetcher) | 31 GamepadService::GamepadService( |
31 : provider_(new GamepadProvider(std::move(fetcher))), | 32 std::unique_ptr<device::GamepadDataFetcher> fetcher) |
33 : provider_(new device::GamepadProvider( | |
34 std::unique_ptr<device::GamepadSharedBuffer>( | |
piman
2016/06/22 22:52:59
nit: base::MakeUnique<GamepadSharedBufferImpl>() s
| |
35 new GamepadSharedBufferImpl), this, std::move(fetcher))), | |
32 num_active_consumers_(0), | 36 num_active_consumers_(0), |
33 gesture_callback_pending_(false) { | 37 gesture_callback_pending_(false) { |
34 SetInstance(this); | 38 SetInstance(this); |
35 thread_checker_.DetachFromThread(); | 39 thread_checker_.DetachFromThread(); |
36 } | 40 } |
37 | 41 |
38 GamepadService::~GamepadService() { | 42 GamepadService::~GamepadService() { |
39 SetInstance(NULL); | 43 SetInstance(NULL); |
40 } | 44 } |
41 | 45 |
42 void GamepadService::SetInstance(GamepadService* instance) { | 46 void GamepadService::SetInstance(GamepadService* instance) { |
43 // Unit tests can create multiple instances but only one should exist at any | 47 // Unit tests can create multiple instances but only one should exist at any |
44 // given time so g_gamepad_service should only go from NULL to non-NULL and | 48 // given time so g_gamepad_service should only go from NULL to non-NULL and |
45 // vica versa. | 49 // vica versa. |
46 CHECK(!!instance != !!g_gamepad_service); | 50 CHECK(!!instance != !!g_gamepad_service); |
47 g_gamepad_service = instance; | 51 g_gamepad_service = instance; |
48 } | 52 } |
49 | 53 |
50 GamepadService* GamepadService::GetInstance() { | 54 GamepadService* GamepadService::GetInstance() { |
51 if (!g_gamepad_service) | 55 if (!g_gamepad_service) |
52 g_gamepad_service = new GamepadService; | 56 g_gamepad_service = new GamepadService; |
53 return g_gamepad_service; | 57 return g_gamepad_service; |
54 } | 58 } |
55 | 59 |
56 void GamepadService::ConsumerBecameActive(GamepadConsumer* consumer) { | 60 void GamepadService::ConsumerBecameActive(device::GamepadConsumer* consumer) { |
57 DCHECK(thread_checker_.CalledOnValidThread()); | 61 DCHECK(thread_checker_.CalledOnValidThread()); |
58 | 62 |
59 if (!provider_) | 63 if (!provider_) |
60 provider_.reset(new GamepadProvider); | 64 provider_.reset(new device::GamepadProvider( |
65 std::unique_ptr<device::GamepadSharedBuffer>( | |
piman
2016/06/22 22:52:59
nit: ditto.
| |
66 new GamepadSharedBufferImpl), | |
67 this)); | |
61 | 68 |
62 std::pair<ConsumerSet::iterator, bool> insert_result = | 69 std::pair<ConsumerSet::iterator, bool> insert_result = |
63 consumers_.insert(consumer); | 70 consumers_.insert(consumer); |
64 insert_result.first->is_active = true; | 71 insert_result.first->is_active = true; |
65 if (!insert_result.first->did_observe_user_gesture && | 72 if (!insert_result.first->did_observe_user_gesture && |
66 !gesture_callback_pending_) { | 73 !gesture_callback_pending_) { |
67 gesture_callback_pending_ = true; | 74 gesture_callback_pending_ = true; |
68 provider_->RegisterForUserGesture( | 75 provider_->RegisterForUserGesture( |
69 base::Bind(&GamepadService::OnUserGesture, | 76 base::Bind(&GamepadService::OnUserGesture, |
70 base::Unretained(this))); | 77 base::Unretained(this))); |
71 } | 78 } |
72 | 79 |
73 if (num_active_consumers_++ == 0) | 80 if (num_active_consumers_++ == 0) |
74 provider_->Resume(); | 81 provider_->Resume(); |
75 } | 82 } |
76 | 83 |
77 void GamepadService::ConsumerBecameInactive(GamepadConsumer* consumer) { | 84 void GamepadService::ConsumerBecameInactive(device::GamepadConsumer* consumer) { |
78 DCHECK(provider_); | 85 DCHECK(provider_); |
79 DCHECK(num_active_consumers_ > 0); | 86 DCHECK(num_active_consumers_ > 0); |
80 DCHECK(consumers_.count(consumer) > 0); | 87 DCHECK(consumers_.count(consumer) > 0); |
81 DCHECK(consumers_.find(consumer)->is_active); | 88 DCHECK(consumers_.find(consumer)->is_active); |
82 | 89 |
83 consumers_.find(consumer)->is_active = false; | 90 consumers_.find(consumer)->is_active = false; |
84 if (--num_active_consumers_ == 0) | 91 if (--num_active_consumers_ == 0) |
85 provider_->Pause(); | 92 provider_->Pause(); |
86 } | 93 } |
87 | 94 |
88 void GamepadService::RemoveConsumer(GamepadConsumer* consumer) { | 95 void GamepadService::RemoveConsumer(device::GamepadConsumer* consumer) { |
89 DCHECK(thread_checker_.CalledOnValidThread()); | 96 DCHECK(thread_checker_.CalledOnValidThread()); |
90 | 97 |
91 ConsumerSet::iterator it = consumers_.find(consumer); | 98 ConsumerSet::iterator it = consumers_.find(consumer); |
92 if (it->is_active && --num_active_consumers_ == 0) | 99 if (it->is_active && --num_active_consumers_ == 0) |
93 provider_->Pause(); | 100 provider_->Pause(); |
94 consumers_.erase(it); | 101 consumers_.erase(it); |
95 } | 102 } |
96 | 103 |
97 void GamepadService::RegisterForUserGesture(const base::Closure& closure) { | 104 void GamepadService::RegisterForUserGesture(const base::Closure& closure) { |
98 DCHECK(consumers_.size() > 0); | 105 DCHECK(consumers_.size() > 0); |
99 DCHECK(thread_checker_.CalledOnValidThread()); | 106 DCHECK(thread_checker_.CalledOnValidThread()); |
100 provider_->RegisterForUserGesture(closure); | 107 provider_->RegisterForUserGesture(closure); |
101 } | 108 } |
102 | 109 |
103 void GamepadService::Terminate() { | 110 void GamepadService::Terminate() { |
104 provider_.reset(); | 111 provider_.reset(); |
105 } | 112 } |
106 | 113 |
114 void GamepadService::OnGamepadConnectionChange(bool connected, | |
115 int index, | |
116 const blink::WebGamepad& pad) { | |
117 if (connected) { | |
118 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
119 base::Bind(&GamepadService::OnGamepadConnected, | |
120 base::Unretained(this), index, pad)); | |
piman
2016/06/22 22:52:59
What makes Unretained safe?
| |
121 } else { | |
122 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
123 base::Bind(&GamepadService::OnGamepadDisconnected, | |
124 base::Unretained(this), index, pad)); | |
piman
2016/06/22 22:52:59
ditto
| |
125 } | |
126 } | |
127 | |
107 void GamepadService::OnGamepadConnected( | 128 void GamepadService::OnGamepadConnected( |
108 int index, | 129 int index, |
109 const blink::WebGamepad& pad) { | 130 const blink::WebGamepad& pad) { |
110 DCHECK(thread_checker_.CalledOnValidThread()); | 131 DCHECK(thread_checker_.CalledOnValidThread()); |
111 | 132 |
112 for (ConsumerSet::iterator it = consumers_.begin(); | 133 for (ConsumerSet::iterator it = consumers_.begin(); |
113 it != consumers_.end(); ++it) { | 134 it != consumers_.end(); ++it) { |
114 if (it->did_observe_user_gesture && it->is_active) | 135 if (it->did_observe_user_gesture && it->is_active) |
115 it->consumer->OnGamepadConnected(index, pad); | 136 it->consumer->OnGamepadConnected(index, pad); |
116 } | 137 } |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
153 for (unsigned i = 0; i < blink::WebGamepads::itemsLengthCap; ++i) { | 174 for (unsigned i = 0; i < blink::WebGamepads::itemsLengthCap; ++i) { |
154 const blink::WebGamepad& pad = gamepads.items[i]; | 175 const blink::WebGamepad& pad = gamepads.items[i]; |
155 if (pad.connected) | 176 if (pad.connected) |
156 info.consumer->OnGamepadConnected(i, pad); | 177 info.consumer->OnGamepadConnected(i, pad); |
157 } | 178 } |
158 } | 179 } |
159 } | 180 } |
160 } | 181 } |
161 | 182 |
162 } // namespace content | 183 } // namespace content |
OLD | NEW |