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 "extensions/browser/api/bluetooth/bluetooth_event_router.h" | 5 #include "extensions/browser/api/bluetooth/bluetooth_event_router.h" |
6 | 6 |
7 #include <map> | 7 #include <map> |
8 #include <string> | 8 #include <string> |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
11 #include "base/bind.h" | 11 #include "base/bind.h" |
12 #include "base/bind_helpers.h" | 12 #include "base/bind_helpers.h" |
13 #include "base/lazy_instance.h" | 13 #include "base/lazy_instance.h" |
14 #include "base/logging.h" | 14 #include "base/logging.h" |
15 #include "base/memory/ref_counted.h" | 15 #include "base/memory/ref_counted.h" |
16 #include "base/stl_util.h" | 16 #include "base/stl_util.h" |
17 #include "base/strings/utf_string_conversions.h" | 17 #include "base/strings/utf_string_conversions.h" |
18 #include "build/build_config.h" | 18 #include "build/build_config.h" |
| 19 #include "components/device_event_log/device_event_log.h" |
19 #include "content/public/browser/notification_details.h" | 20 #include "content/public/browser/notification_details.h" |
20 #include "content/public/browser/notification_source.h" | 21 #include "content/public/browser/notification_source.h" |
21 #include "device/bluetooth/bluetooth_adapter.h" | 22 #include "device/bluetooth/bluetooth_adapter.h" |
22 #include "device/bluetooth/bluetooth_adapter_factory.h" | 23 #include "device/bluetooth/bluetooth_adapter_factory.h" |
23 #include "device/bluetooth/bluetooth_device.h" | 24 #include "device/bluetooth/bluetooth_device.h" |
24 #include "device/bluetooth/bluetooth_discovery_session.h" | 25 #include "device/bluetooth/bluetooth_discovery_session.h" |
25 #include "extensions/browser/api/bluetooth/bluetooth_api_pairing_delegate.h" | 26 #include "extensions/browser/api/bluetooth/bluetooth_api_pairing_delegate.h" |
26 #include "extensions/browser/api/bluetooth/bluetooth_api_utils.h" | 27 #include "extensions/browser/api/bluetooth/bluetooth_api_utils.h" |
27 #include "extensions/browser/api/bluetooth/bluetooth_private_api.h" | 28 #include "extensions/browser/api/bluetooth/bluetooth_private_api.h" |
28 #include "extensions/browser/event_router.h" | 29 #include "extensions/browser/event_router.h" |
(...skipping 20 matching lines...) Expand all Loading... |
49 namespace bluetooth = api::bluetooth; | 50 namespace bluetooth = api::bluetooth; |
50 namespace bt_private = api::bluetooth_private; | 51 namespace bt_private = api::bluetooth_private; |
51 | 52 |
52 BluetoothEventRouter::BluetoothEventRouter(content::BrowserContext* context) | 53 BluetoothEventRouter::BluetoothEventRouter(content::BrowserContext* context) |
53 : browser_context_(context), | 54 : browser_context_(context), |
54 adapter_(nullptr), | 55 adapter_(nullptr), |
55 num_event_listeners_(0), | 56 num_event_listeners_(0), |
56 extension_registry_observer_(this), | 57 extension_registry_observer_(this), |
57 weak_ptr_factory_(this) { | 58 weak_ptr_factory_(this) { |
58 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 59 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| 60 BLUETOOTH_LOG(USER) << "BluetoothEventRouter()"; |
59 DCHECK(browser_context_); | 61 DCHECK(browser_context_); |
60 registrar_.Add(this, | 62 registrar_.Add(this, extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED, |
61 extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED, | |
62 content::Source<content::BrowserContext>(browser_context_)); | 63 content::Source<content::BrowserContext>(browser_context_)); |
63 extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_)); | 64 extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_)); |
64 } | 65 } |
65 | 66 |
66 BluetoothEventRouter::~BluetoothEventRouter() { | 67 BluetoothEventRouter::~BluetoothEventRouter() { |
67 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 68 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| 69 BLUETOOTH_LOG(USER) << "~BluetoothEventRouter()"; |
68 if (adapter_.get()) { | 70 if (adapter_.get()) { |
69 adapter_->RemoveObserver(this); | 71 adapter_->RemoveObserver(this); |
70 adapter_ = nullptr; | 72 adapter_ = nullptr; |
71 } | 73 } |
72 CleanUpAllExtensions(); | 74 CleanUpAllExtensions(); |
73 } | 75 } |
74 | 76 |
75 bool BluetoothEventRouter::IsBluetoothSupported() const { | 77 bool BluetoothEventRouter::IsBluetoothSupported() const { |
76 return adapter_.get() || | 78 return adapter_.get() || |
77 device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable(); | 79 device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable(); |
78 } | 80 } |
79 | 81 |
80 void BluetoothEventRouter::GetAdapter( | 82 void BluetoothEventRouter::GetAdapter( |
81 const device::BluetoothAdapterFactory::AdapterCallback& callback) { | 83 const device::BluetoothAdapterFactory::AdapterCallback& callback) { |
82 if (adapter_.get()) { | 84 if (adapter_.get()) { |
83 callback.Run(scoped_refptr<device::BluetoothAdapter>(adapter_)); | 85 callback.Run(scoped_refptr<device::BluetoothAdapter>(adapter_)); |
84 return; | 86 return; |
85 } | 87 } |
86 | 88 |
87 device::BluetoothAdapterFactory::GetAdapter( | 89 device::BluetoothAdapterFactory::GetAdapter( |
88 base::Bind(&BluetoothEventRouter::OnAdapterInitialized, | 90 base::Bind(&BluetoothEventRouter::OnAdapterInitialized, |
89 weak_ptr_factory_.GetWeakPtr(), callback)); | 91 weak_ptr_factory_.GetWeakPtr(), callback)); |
90 } | 92 } |
91 | 93 |
92 void BluetoothEventRouter::StartDiscoverySession( | 94 void BluetoothEventRouter::StartDiscoverySession( |
93 device::BluetoothAdapter* adapter, | 95 device::BluetoothAdapter* adapter, |
94 const std::string& extension_id, | 96 const std::string& extension_id, |
95 const base::Closure& callback, | 97 const base::Closure& callback, |
96 const base::Closure& error_callback) { | 98 const base::Closure& error_callback) { |
| 99 BLUETOOTH_LOG(USER) << "StartDiscoverySession"; |
97 if (!adapter_.get() && IsBluetoothSupported()) { | 100 if (!adapter_.get() && IsBluetoothSupported()) { |
98 // If |adapter_| isn't set yet, call GetAdapter() which will synchronously | 101 // If |adapter_| isn't set yet, call GetAdapter() which will synchronously |
99 // invoke the callback (StartDiscoverySessionImpl). | 102 // invoke the callback (StartDiscoverySessionImpl). |
100 GetAdapter(base::Bind( | 103 GetAdapter(base::Bind( |
101 &IgnoreAdapterResultAndThen, | 104 &IgnoreAdapterResultAndThen, |
102 base::Bind(&BluetoothEventRouter::StartDiscoverySessionImpl, | 105 base::Bind(&BluetoothEventRouter::StartDiscoverySessionImpl, |
103 weak_ptr_factory_.GetWeakPtr(), base::RetainedRef(adapter), | 106 weak_ptr_factory_.GetWeakPtr(), base::RetainedRef(adapter), |
104 extension_id, callback, error_callback))); | 107 extension_id, callback, error_callback))); |
105 return; | 108 return; |
106 } | 109 } |
107 StartDiscoverySessionImpl(adapter, extension_id, callback, error_callback); | 110 StartDiscoverySessionImpl(adapter, extension_id, callback, error_callback); |
108 } | 111 } |
109 | 112 |
110 void BluetoothEventRouter::StartDiscoverySessionImpl( | 113 void BluetoothEventRouter::StartDiscoverySessionImpl( |
111 device::BluetoothAdapter* adapter, | 114 device::BluetoothAdapter* adapter, |
112 const std::string& extension_id, | 115 const std::string& extension_id, |
113 const base::Closure& callback, | 116 const base::Closure& callback, |
114 const base::Closure& error_callback) { | 117 const base::Closure& error_callback) { |
115 if (!adapter_.get()) { | 118 if (!adapter_.get()) { |
116 LOG(ERROR) << "Unable to get Bluetooth adapter."; | 119 BLUETOOTH_LOG(ERROR) << "Unable to get Bluetooth adapter."; |
117 error_callback.Run(); | 120 error_callback.Run(); |
118 return; | 121 return; |
119 } | 122 } |
120 if (adapter != adapter_.get()) { | 123 if (adapter != adapter_.get()) { |
121 LOG(ERROR) << "Bluetooth adapter mismatch."; | 124 BLUETOOTH_LOG(ERROR) << "Bluetooth adapter mismatch."; |
122 error_callback.Run(); | 125 error_callback.Run(); |
123 return; | 126 return; |
124 } | 127 } |
125 DiscoverySessionMap::iterator iter = | 128 DiscoverySessionMap::iterator iter = |
126 discovery_session_map_.find(extension_id); | 129 discovery_session_map_.find(extension_id); |
127 if (iter != discovery_session_map_.end() && iter->second->IsActive()) { | 130 if (iter != discovery_session_map_.end() && iter->second->IsActive()) { |
128 DVLOG(1) << "An active discovery session exists for extension."; | 131 BLUETOOTH_LOG(DEBUG) << "An active discovery session exists for extension: " |
| 132 << extension_id; |
129 error_callback.Run(); | 133 error_callback.Run(); |
130 return; | 134 return; |
131 } | 135 } |
132 | 136 |
133 // Check whether user pre set discovery filter by calling SetDiscoveryFilter | 137 // Check whether user pre set discovery filter by calling SetDiscoveryFilter |
134 // before. If the user has set a discovery filter then start a filtered | 138 // before. If the user has set a discovery filter then start a filtered |
135 // discovery session, otherwise start a regular session | 139 // discovery session, otherwise start a regular session |
136 PreSetFilterMap::iterator pre_set_iter = | 140 PreSetFilterMap::iterator pre_set_iter = |
137 pre_set_filter_map_.find(extension_id); | 141 pre_set_filter_map_.find(extension_id); |
138 if (pre_set_iter != pre_set_filter_map_.end()) { | 142 if (pre_set_iter != pre_set_filter_map_.end()) { |
(...skipping 13 matching lines...) Expand all Loading... |
152 | 156 |
153 void BluetoothEventRouter::StopDiscoverySession( | 157 void BluetoothEventRouter::StopDiscoverySession( |
154 device::BluetoothAdapter* adapter, | 158 device::BluetoothAdapter* adapter, |
155 const std::string& extension_id, | 159 const std::string& extension_id, |
156 const base::Closure& callback, | 160 const base::Closure& callback, |
157 const base::Closure& error_callback) { | 161 const base::Closure& error_callback) { |
158 if (adapter != adapter_.get()) { | 162 if (adapter != adapter_.get()) { |
159 error_callback.Run(); | 163 error_callback.Run(); |
160 return; | 164 return; |
161 } | 165 } |
| 166 BLUETOOTH_LOG(USER) << "StopDiscoverySession"; |
162 DiscoverySessionMap::iterator iter = | 167 DiscoverySessionMap::iterator iter = |
163 discovery_session_map_.find(extension_id); | 168 discovery_session_map_.find(extension_id); |
164 if (iter == discovery_session_map_.end() || !iter->second->IsActive()) { | 169 if (iter == discovery_session_map_.end() || !iter->second->IsActive()) { |
165 DVLOG(1) << "No active discovery session exists for extension."; | 170 BLUETOOTH_LOG(DEBUG) << "No active discovery session exists for extension."; |
166 error_callback.Run(); | 171 error_callback.Run(); |
167 return; | 172 return; |
168 } | 173 } |
169 device::BluetoothDiscoverySession* session = iter->second; | 174 device::BluetoothDiscoverySession* session = iter->second; |
170 session->Stop(callback, error_callback); | 175 session->Stop(callback, error_callback); |
171 } | 176 } |
172 | 177 |
173 void BluetoothEventRouter::SetDiscoveryFilter( | 178 void BluetoothEventRouter::SetDiscoveryFilter( |
174 std::unique_ptr<device::BluetoothDiscoveryFilter> discovery_filter, | 179 std::unique_ptr<device::BluetoothDiscoveryFilter> discovery_filter, |
175 device::BluetoothAdapter* adapter, | 180 device::BluetoothAdapter* adapter, |
176 const std::string& extension_id, | 181 const std::string& extension_id, |
177 const base::Closure& callback, | 182 const base::Closure& callback, |
178 const base::Closure& error_callback) { | 183 const base::Closure& error_callback) { |
179 DVLOG(1) << "SetDiscoveryFilter"; | 184 BLUETOOTH_LOG(USER) << "SetDiscoveryFilter"; |
180 if (adapter != adapter_.get()) { | 185 if (adapter != adapter_.get()) { |
181 error_callback.Run(); | 186 error_callback.Run(); |
182 return; | 187 return; |
183 } | 188 } |
184 | 189 |
185 DiscoverySessionMap::iterator iter = | 190 DiscoverySessionMap::iterator iter = |
186 discovery_session_map_.find(extension_id); | 191 discovery_session_map_.find(extension_id); |
187 if (iter == discovery_session_map_.end() || !iter->second->IsActive()) { | 192 if (iter == discovery_session_map_.end() || !iter->second->IsActive()) { |
188 DVLOG(1) << "No active discovery session exists for extension, so caching " | 193 BLUETOOTH_LOG(DEBUG) << "No active discovery session exists for extension, " |
189 "filter for later use."; | 194 << "so caching filter for later use."; |
190 pre_set_filter_map_[extension_id] = discovery_filter.release(); | 195 pre_set_filter_map_[extension_id] = discovery_filter.release(); |
191 callback.Run(); | 196 callback.Run(); |
192 return; | 197 return; |
193 } | 198 } |
194 | 199 |
195 // extension is already running discovery, update it's discovery filter | 200 // extension is already running discovery, update it's discovery filter |
196 iter->second->SetDiscoveryFilter(std::move(discovery_filter), callback, | 201 iter->second->SetDiscoveryFilter(std::move(discovery_filter), callback, |
197 error_callback); | 202 error_callback); |
198 } | 203 } |
199 | 204 |
(...skipping 11 matching lines...) Expand all Loading... |
211 adapter_ = adapter; | 216 adapter_ = adapter; |
212 adapter_->AddObserver(this); | 217 adapter_->AddObserver(this); |
213 } | 218 } |
214 | 219 |
215 callback.Run(adapter); | 220 callback.Run(adapter); |
216 } | 221 } |
217 | 222 |
218 void BluetoothEventRouter::MaybeReleaseAdapter() { | 223 void BluetoothEventRouter::MaybeReleaseAdapter() { |
219 if (adapter_.get() && num_event_listeners_ == 0 && | 224 if (adapter_.get() && num_event_listeners_ == 0 && |
220 pairing_delegate_map_.empty()) { | 225 pairing_delegate_map_.empty()) { |
221 VLOG(1) << "Releasing Adapter."; | 226 BLUETOOTH_LOG(EVENT) << "Releasing Adapter."; |
| 227 // When a tab is closed, OnExtensionUnloaded may not get called, so when |
| 228 // we release the adapter, also clean up any discovery sessions. |
| 229 CleanUpAllExtensions(); |
222 adapter_->RemoveObserver(this); | 230 adapter_->RemoveObserver(this); |
223 adapter_ = nullptr; | 231 adapter_ = nullptr; |
224 } | 232 } |
225 } | 233 } |
226 | 234 |
227 void BluetoothEventRouter::AddPairingDelegate(const std::string& extension_id) { | 235 void BluetoothEventRouter::AddPairingDelegate(const std::string& extension_id) { |
228 if (!adapter_.get() && IsBluetoothSupported()) { | 236 if (!adapter_.get() && IsBluetoothSupported()) { |
229 GetAdapter( | 237 GetAdapter( |
230 base::Bind(&IgnoreAdapterResultAndThen, | 238 base::Bind(&IgnoreAdapterResultAndThen, |
231 base::Bind(&BluetoothEventRouter::AddPairingDelegateImpl, | 239 base::Bind(&BluetoothEventRouter::AddPairingDelegateImpl, |
232 weak_ptr_factory_.GetWeakPtr(), extension_id))); | 240 weak_ptr_factory_.GetWeakPtr(), extension_id))); |
233 return; | 241 return; |
234 } | 242 } |
235 AddPairingDelegateImpl(extension_id); | 243 AddPairingDelegateImpl(extension_id); |
236 } | 244 } |
237 | 245 |
238 void BluetoothEventRouter::AddPairingDelegateImpl( | 246 void BluetoothEventRouter::AddPairingDelegateImpl( |
239 const std::string& extension_id) { | 247 const std::string& extension_id) { |
240 if (!adapter_.get()) { | 248 if (!adapter_.get()) { |
241 LOG(ERROR) << "Unable to get adapter for extension_id: " << extension_id; | 249 LOG(ERROR) << "Unable to get adapter for extension_id: " << extension_id; |
242 return; | 250 return; |
243 } | 251 } |
244 if (base::ContainsKey(pairing_delegate_map_, extension_id)) { | 252 if (base::ContainsKey(pairing_delegate_map_, extension_id)) { |
245 // For WebUI there may be more than one page open to the same url | 253 // For WebUI there may be more than one page open to the same url |
246 // (e.g. chrome://settings). These will share the same pairing delegate. | 254 // (e.g. chrome://settings). These will share the same pairing delegate. |
247 VLOG(1) << "Pairing delegate already exists for extension_id: " | 255 BLUETOOTH_LOG(EVENT) << "Pairing delegate already exists for extension_id: " |
248 << extension_id; | 256 << extension_id; |
249 return; | 257 return; |
250 } | 258 } |
251 BluetoothApiPairingDelegate* delegate = | 259 BluetoothApiPairingDelegate* delegate = |
252 new BluetoothApiPairingDelegate(browser_context_); | 260 new BluetoothApiPairingDelegate(browser_context_); |
253 DCHECK(adapter_.get()); | 261 DCHECK(adapter_.get()); |
254 adapter_->AddPairingDelegate( | 262 adapter_->AddPairingDelegate( |
255 delegate, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH); | 263 delegate, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH); |
256 pairing_delegate_map_[extension_id] = delegate; | 264 pairing_delegate_map_[extension_id] = delegate; |
257 } | 265 } |
258 | 266 |
259 void BluetoothEventRouter::RemovePairingDelegate( | 267 void BluetoothEventRouter::RemovePairingDelegate( |
260 const std::string& extension_id) { | 268 const std::string& extension_id) { |
261 if (base::ContainsKey(pairing_delegate_map_, extension_id)) { | 269 if (base::ContainsKey(pairing_delegate_map_, extension_id)) { |
262 BluetoothApiPairingDelegate* delegate = pairing_delegate_map_[extension_id]; | 270 BluetoothApiPairingDelegate* delegate = pairing_delegate_map_[extension_id]; |
263 if (adapter_.get()) | 271 if (adapter_.get()) |
264 adapter_->RemovePairingDelegate(delegate); | 272 adapter_->RemovePairingDelegate(delegate); |
265 pairing_delegate_map_.erase(extension_id); | 273 pairing_delegate_map_.erase(extension_id); |
266 delete delegate; | 274 delete delegate; |
267 MaybeReleaseAdapter(); | 275 MaybeReleaseAdapter(); |
268 } | 276 } |
269 } | 277 } |
270 | 278 |
271 void BluetoothEventRouter::AdapterPresentChanged( | 279 void BluetoothEventRouter::AdapterPresentChanged( |
272 device::BluetoothAdapter* adapter, | 280 device::BluetoothAdapter* adapter, |
273 bool present) { | 281 bool present) { |
274 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 282 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
275 if (adapter != adapter_.get()) { | 283 if (adapter != adapter_.get()) { |
276 DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress(); | 284 BLUETOOTH_LOG(DEBUG) << "Ignoring event for adapter " |
| 285 << adapter->GetAddress(); |
277 return; | 286 return; |
278 } | 287 } |
279 DispatchAdapterStateEvent(); | 288 DispatchAdapterStateEvent(); |
280 } | 289 } |
281 | 290 |
282 void BluetoothEventRouter::AdapterPoweredChanged( | 291 void BluetoothEventRouter::AdapterPoweredChanged( |
283 device::BluetoothAdapter* adapter, | 292 device::BluetoothAdapter* adapter, |
284 bool has_power) { | 293 bool has_power) { |
285 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 294 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
286 if (adapter != adapter_.get()) { | 295 if (adapter != adapter_.get()) { |
287 DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress(); | 296 BLUETOOTH_LOG(DEBUG) << "Ignoring event for adapter " |
| 297 << adapter->GetAddress(); |
288 return; | 298 return; |
289 } | 299 } |
290 DispatchAdapterStateEvent(); | 300 DispatchAdapterStateEvent(); |
291 } | 301 } |
292 | 302 |
293 void BluetoothEventRouter::AdapterDiscoveringChanged( | 303 void BluetoothEventRouter::AdapterDiscoveringChanged( |
294 device::BluetoothAdapter* adapter, | 304 device::BluetoothAdapter* adapter, |
295 bool discovering) { | 305 bool discovering) { |
296 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 306 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
297 if (adapter != adapter_.get()) { | 307 if (adapter != adapter_.get()) { |
298 DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress(); | 308 BLUETOOTH_LOG(DEBUG) << "Ignoring event for adapter " |
| 309 << adapter->GetAddress(); |
299 return; | 310 return; |
300 } | 311 } |
301 | 312 |
302 if (!discovering) { | 313 if (!discovering) { |
303 // If any discovery sessions are inactive, clean them up. | 314 // If any discovery sessions are inactive, clean them up. |
304 DiscoverySessionMap active_session_map; | 315 DiscoverySessionMap active_session_map; |
305 for (DiscoverySessionMap::iterator iter = discovery_session_map_.begin(); | 316 for (DiscoverySessionMap::iterator iter = discovery_session_map_.begin(); |
306 iter != discovery_session_map_.end(); | 317 iter != discovery_session_map_.end(); ++iter) { |
307 ++iter) { | |
308 device::BluetoothDiscoverySession* session = iter->second; | 318 device::BluetoothDiscoverySession* session = iter->second; |
309 if (session->IsActive()) { | 319 if (session->IsActive()) { |
310 active_session_map[iter->first] = session; | 320 active_session_map[iter->first] = session; |
311 continue; | 321 continue; |
312 } | 322 } |
313 delete session; | 323 delete session; |
314 } | 324 } |
315 discovery_session_map_.swap(active_session_map); | 325 discovery_session_map_.swap(active_session_map); |
316 } | 326 } |
317 | 327 |
318 DispatchAdapterStateEvent(); | 328 DispatchAdapterStateEvent(); |
319 | 329 |
320 // Release the adapter after dispatching the event. | 330 // Release the adapter after dispatching the event. |
321 if (!discovering) | 331 if (!discovering) |
322 MaybeReleaseAdapter(); | 332 MaybeReleaseAdapter(); |
323 } | 333 } |
324 | 334 |
325 void BluetoothEventRouter::DeviceAdded(device::BluetoothAdapter* adapter, | 335 void BluetoothEventRouter::DeviceAdded(device::BluetoothAdapter* adapter, |
326 device::BluetoothDevice* device) { | 336 device::BluetoothDevice* device) { |
327 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 337 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
328 if (adapter != adapter_.get()) { | 338 if (adapter != adapter_.get()) { |
329 DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress(); | 339 BLUETOOTH_LOG(DEBUG) << "Ignoring event for adapter " |
| 340 << adapter->GetAddress(); |
330 return; | 341 return; |
331 } | 342 } |
332 | 343 |
333 DispatchDeviceEvent(events::BLUETOOTH_ON_DEVICE_ADDED, | 344 DispatchDeviceEvent(events::BLUETOOTH_ON_DEVICE_ADDED, |
334 bluetooth::OnDeviceAdded::kEventName, device); | 345 bluetooth::OnDeviceAdded::kEventName, device); |
335 } | 346 } |
336 | 347 |
337 void BluetoothEventRouter::DeviceChanged(device::BluetoothAdapter* adapter, | 348 void BluetoothEventRouter::DeviceChanged(device::BluetoothAdapter* adapter, |
338 device::BluetoothDevice* device) { | 349 device::BluetoothDevice* device) { |
339 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 350 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
340 if (adapter != adapter_.get()) { | 351 if (adapter != adapter_.get()) { |
341 DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress(); | 352 BLUETOOTH_LOG(DEBUG) << "Ignoring event for adapter " |
| 353 << adapter->GetAddress(); |
342 return; | 354 return; |
343 } | 355 } |
344 | 356 |
345 DispatchDeviceEvent(events::BLUETOOTH_ON_DEVICE_CHANGED, | 357 DispatchDeviceEvent(events::BLUETOOTH_ON_DEVICE_CHANGED, |
346 bluetooth::OnDeviceChanged::kEventName, device); | 358 bluetooth::OnDeviceChanged::kEventName, device); |
347 } | 359 } |
348 | 360 |
349 void BluetoothEventRouter::DeviceRemoved(device::BluetoothAdapter* adapter, | 361 void BluetoothEventRouter::DeviceRemoved(device::BluetoothAdapter* adapter, |
350 device::BluetoothDevice* device) { | 362 device::BluetoothDevice* device) { |
351 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 363 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
352 if (adapter != adapter_.get()) { | 364 if (adapter != adapter_.get()) { |
353 DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress(); | 365 BLUETOOTH_LOG(DEBUG) << "Ignoring event for adapter " |
| 366 << adapter->GetAddress(); |
354 return; | 367 return; |
355 } | 368 } |
356 | 369 |
357 DispatchDeviceEvent(events::BLUETOOTH_ON_DEVICE_REMOVED, | 370 DispatchDeviceEvent(events::BLUETOOTH_ON_DEVICE_REMOVED, |
358 bluetooth::OnDeviceRemoved::kEventName, device); | 371 bluetooth::OnDeviceRemoved::kEventName, device); |
359 } | 372 } |
360 | 373 |
361 void BluetoothEventRouter::OnListenerAdded() { | 374 void BluetoothEventRouter::OnListenerAdded() { |
362 num_event_listeners_++; | 375 num_event_listeners_++; |
363 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 376 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
395 | 408 |
396 std::unique_ptr<base::ListValue> args = | 409 std::unique_ptr<base::ListValue> args = |
397 bluetooth::OnDeviceAdded::Create(extension_device); | 410 bluetooth::OnDeviceAdded::Create(extension_device); |
398 std::unique_ptr<Event> event( | 411 std::unique_ptr<Event> event( |
399 new Event(histogram_value, event_name, std::move(args))); | 412 new Event(histogram_value, event_name, std::move(args))); |
400 EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event)); | 413 EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event)); |
401 } | 414 } |
402 | 415 |
403 void BluetoothEventRouter::CleanUpForExtension( | 416 void BluetoothEventRouter::CleanUpForExtension( |
404 const std::string& extension_id) { | 417 const std::string& extension_id) { |
| 418 BLUETOOTH_LOG(DEBUG) << "CleanUpForExtension: " << extension_id; |
405 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 419 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
406 RemovePairingDelegate(extension_id); | 420 RemovePairingDelegate(extension_id); |
407 | 421 |
408 PreSetFilterMap::iterator pre_set_iter = | 422 PreSetFilterMap::iterator pre_set_iter = |
409 pre_set_filter_map_.find(extension_id); | 423 pre_set_filter_map_.find(extension_id); |
410 if (pre_set_iter != pre_set_filter_map_.end()) { | 424 if (pre_set_iter != pre_set_filter_map_.end()) { |
411 delete pre_set_iter->second; | 425 delete pre_set_iter->second; |
412 pre_set_filter_map_.erase(pre_set_iter); | 426 pre_set_filter_map_.erase(pre_set_iter); |
413 } | 427 } |
414 | 428 |
415 // Remove any discovery session initiated by the extension. | 429 // Remove any discovery session initiated by the extension. |
416 DiscoverySessionMap::iterator session_iter = | 430 DiscoverySessionMap::iterator session_iter = |
417 discovery_session_map_.find(extension_id); | 431 discovery_session_map_.find(extension_id); |
418 if (session_iter == discovery_session_map_.end()) | 432 if (session_iter == discovery_session_map_.end()) |
419 return; | 433 return; |
420 delete session_iter->second; | 434 delete session_iter->second; |
421 discovery_session_map_.erase(session_iter); | 435 discovery_session_map_.erase(session_iter); |
422 } | 436 } |
423 | 437 |
424 void BluetoothEventRouter::CleanUpAllExtensions() { | 438 void BluetoothEventRouter::CleanUpAllExtensions() { |
| 439 BLUETOOTH_LOG(DEBUG) << "CleanUpAllExtensions"; |
425 for (auto& it : pre_set_filter_map_) | 440 for (auto& it : pre_set_filter_map_) |
426 delete it.second; | 441 delete it.second; |
427 | 442 |
428 pre_set_filter_map_.clear(); | 443 pre_set_filter_map_.clear(); |
429 | 444 |
430 for (auto& it : discovery_session_map_) | 445 for (auto& it : discovery_session_map_) |
431 delete it.second; | 446 delete it.second; |
432 | 447 |
433 discovery_session_map_.clear(); | 448 discovery_session_map_.clear(); |
434 | 449 |
435 PairingDelegateMap::iterator pairing_iter = pairing_delegate_map_.begin(); | 450 PairingDelegateMap::iterator pairing_iter = pairing_delegate_map_.begin(); |
436 while (pairing_iter != pairing_delegate_map_.end()) | 451 while (pairing_iter != pairing_delegate_map_.end()) |
437 RemovePairingDelegate(pairing_iter++->first); | 452 RemovePairingDelegate(pairing_iter++->first); |
438 } | 453 } |
439 | 454 |
440 void BluetoothEventRouter::OnStartDiscoverySession( | 455 void BluetoothEventRouter::OnStartDiscoverySession( |
441 const std::string& extension_id, | 456 const std::string& extension_id, |
442 const base::Closure& callback, | 457 const base::Closure& callback, |
443 std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) { | 458 std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) { |
| 459 BLUETOOTH_LOG(EVENT) << "OnStartDiscoverySession"; |
444 // Clean up any existing session instance for the extension. | 460 // Clean up any existing session instance for the extension. |
445 DiscoverySessionMap::iterator iter = | 461 DiscoverySessionMap::iterator iter = |
446 discovery_session_map_.find(extension_id); | 462 discovery_session_map_.find(extension_id); |
447 if (iter != discovery_session_map_.end()) | 463 if (iter != discovery_session_map_.end()) |
448 delete iter->second; | 464 delete iter->second; |
449 discovery_session_map_[extension_id] = discovery_session.release(); | 465 discovery_session_map_[extension_id] = discovery_session.release(); |
450 callback.Run(); | 466 callback.Run(); |
451 } | 467 } |
452 | 468 |
453 void BluetoothEventRouter::OnSetDiscoveryFilter(const std::string& extension_id, | 469 void BluetoothEventRouter::OnSetDiscoveryFilter(const std::string& extension_id, |
454 const base::Closure& callback) { | 470 const base::Closure& callback) { |
455 DVLOG(1) << "Successfully set DiscoveryFilter."; | 471 BLUETOOTH_LOG(DEBUG) << "Successfully set DiscoveryFilter."; |
456 callback.Run(); | 472 callback.Run(); |
457 } | 473 } |
458 | 474 |
459 void BluetoothEventRouter::Observe( | 475 void BluetoothEventRouter::Observe( |
460 int type, | 476 int type, |
461 const content::NotificationSource& source, | 477 const content::NotificationSource& source, |
462 const content::NotificationDetails& details) { | 478 const content::NotificationDetails& details) { |
463 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 479 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
464 DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED, type); | 480 DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED, type); |
465 ExtensionHost* host = content::Details<ExtensionHost>(details).ptr(); | 481 ExtensionHost* host = content::Details<ExtensionHost>(details).ptr(); |
466 CleanUpForExtension(host->extension_id()); | 482 CleanUpForExtension(host->extension_id()); |
467 } | 483 } |
468 | 484 |
469 void BluetoothEventRouter::OnExtensionUnloaded( | 485 void BluetoothEventRouter::OnExtensionUnloaded( |
470 content::BrowserContext* browser_context, | 486 content::BrowserContext* browser_context, |
471 const Extension* extension, | 487 const Extension* extension, |
472 UnloadedExtensionInfo::Reason reason) { | 488 UnloadedExtensionInfo::Reason reason) { |
473 CleanUpForExtension(extension->id()); | 489 CleanUpForExtension(extension->id()); |
474 } | 490 } |
475 | 491 |
476 } // namespace extensions | 492 } // namespace extensions |
OLD | NEW |