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 "device/media_transfer_protocol/media_transfer_protocol_manager.h" | 5 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <map> | 8 #include <map> |
9 #include <memory> | 9 #include <memory> |
10 #include <queue> | 10 #include <queue> |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
124 DCHECK(thread_checker_.CalledOnValidThread()); | 124 DCHECK(thread_checker_.CalledOnValidThread()); |
125 StorageInfoMap::const_iterator it = storage_info_map_.find(storage_name); | 125 StorageInfoMap::const_iterator it = storage_info_map_.find(storage_name); |
126 return it != storage_info_map_.end() ? &it->second : NULL; | 126 return it != storage_info_map_.end() ? &it->second : NULL; |
127 } | 127 } |
128 | 128 |
129 // MediaTransferProtocolManager override. | 129 // MediaTransferProtocolManager override. |
130 void GetStorageInfoFromDevice( | 130 void GetStorageInfoFromDevice( |
131 const std::string& storage_name, | 131 const std::string& storage_name, |
132 const GetStorageInfoFromDeviceCallback& callback) override { | 132 const GetStorageInfoFromDeviceCallback& callback) override { |
133 DCHECK(thread_checker_.CalledOnValidThread()); | 133 DCHECK(thread_checker_.CalledOnValidThread()); |
134 if (!ContainsKey(storage_info_map_, storage_name) || !mtp_client_) { | 134 if (!base::ContainsKey(storage_info_map_, storage_name) || !mtp_client_) { |
135 MtpStorageInfo info; | 135 MtpStorageInfo info; |
136 callback.Run(info, true /* error */); | 136 callback.Run(info, true /* error */); |
137 return; | 137 return; |
138 } | 138 } |
139 get_storage_info_from_device_callbacks_.push(callback); | 139 get_storage_info_from_device_callbacks_.push(callback); |
140 mtp_client_->GetStorageInfoFromDevice( | 140 mtp_client_->GetStorageInfoFromDevice( |
141 storage_name, | 141 storage_name, |
142 base::Bind( | 142 base::Bind( |
143 &MediaTransferProtocolManagerImpl::OnGetStorageInfoFromDevice, | 143 &MediaTransferProtocolManagerImpl::OnGetStorageInfoFromDevice, |
144 weak_ptr_factory_.GetWeakPtr()), | 144 weak_ptr_factory_.GetWeakPtr()), |
145 base::Bind( | 145 base::Bind( |
146 &MediaTransferProtocolManagerImpl::OnGetStorageInfoFromDeviceError, | 146 &MediaTransferProtocolManagerImpl::OnGetStorageInfoFromDeviceError, |
147 weak_ptr_factory_.GetWeakPtr())); | 147 weak_ptr_factory_.GetWeakPtr())); |
148 } | 148 } |
149 | 149 |
150 // MediaTransferProtocolManager override. | 150 // MediaTransferProtocolManager override. |
151 void OpenStorage(const std::string& storage_name, | 151 void OpenStorage(const std::string& storage_name, |
152 const std::string& mode, | 152 const std::string& mode, |
153 const OpenStorageCallback& callback) override { | 153 const OpenStorageCallback& callback) override { |
154 DCHECK(thread_checker_.CalledOnValidThread()); | 154 DCHECK(thread_checker_.CalledOnValidThread()); |
155 if (!ContainsKey(storage_info_map_, storage_name) || !mtp_client_) { | 155 if (!base::ContainsKey(storage_info_map_, storage_name) || !mtp_client_) { |
156 callback.Run(std::string(), true); | 156 callback.Run(std::string(), true); |
157 return; | 157 return; |
158 } | 158 } |
159 open_storage_callbacks_.push(callback); | 159 open_storage_callbacks_.push(callback); |
160 mtp_client_->OpenStorage( | 160 mtp_client_->OpenStorage( |
161 storage_name, | 161 storage_name, |
162 mode, | 162 mode, |
163 base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorage, | 163 base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorage, |
164 weak_ptr_factory_.GetWeakPtr()), | 164 weak_ptr_factory_.GetWeakPtr()), |
165 base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorageError, | 165 base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorageError, |
166 weak_ptr_factory_.GetWeakPtr())); | 166 weak_ptr_factory_.GetWeakPtr())); |
167 } | 167 } |
168 | 168 |
169 // MediaTransferProtocolManager override. | 169 // MediaTransferProtocolManager override. |
170 void CloseStorage(const std::string& storage_handle, | 170 void CloseStorage(const std::string& storage_handle, |
171 const CloseStorageCallback& callback) override { | 171 const CloseStorageCallback& callback) override { |
172 DCHECK(thread_checker_.CalledOnValidThread()); | 172 DCHECK(thread_checker_.CalledOnValidThread()); |
173 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 173 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
174 callback.Run(true); | 174 callback.Run(true); |
175 return; | 175 return; |
176 } | 176 } |
177 close_storage_callbacks_.push(std::make_pair(callback, storage_handle)); | 177 close_storage_callbacks_.push(std::make_pair(callback, storage_handle)); |
178 mtp_client_->CloseStorage( | 178 mtp_client_->CloseStorage( |
179 storage_handle, | 179 storage_handle, |
180 base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorage, | 180 base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorage, |
181 weak_ptr_factory_.GetWeakPtr()), | 181 weak_ptr_factory_.GetWeakPtr()), |
182 base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorageError, | 182 base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorageError, |
183 weak_ptr_factory_.GetWeakPtr())); | 183 weak_ptr_factory_.GetWeakPtr())); |
184 } | 184 } |
185 | 185 |
186 void CreateDirectory(const std::string& storage_handle, | 186 void CreateDirectory(const std::string& storage_handle, |
187 const uint32_t parent_id, | 187 const uint32_t parent_id, |
188 const std::string& directory_name, | 188 const std::string& directory_name, |
189 const CreateDirectoryCallback& callback) override { | 189 const CreateDirectoryCallback& callback) override { |
190 DCHECK(thread_checker_.CalledOnValidThread()); | 190 DCHECK(thread_checker_.CalledOnValidThread()); |
191 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 191 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
192 callback.Run(true /* error */); | 192 callback.Run(true /* error */); |
193 return; | 193 return; |
194 } | 194 } |
195 create_directory_callbacks_.push(callback); | 195 create_directory_callbacks_.push(callback); |
196 mtp_client_->CreateDirectory( | 196 mtp_client_->CreateDirectory( |
197 storage_handle, parent_id, directory_name, | 197 storage_handle, parent_id, directory_name, |
198 base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectory, | 198 base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectory, |
199 weak_ptr_factory_.GetWeakPtr()), | 199 weak_ptr_factory_.GetWeakPtr()), |
200 base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectoryError, | 200 base::Bind(&MediaTransferProtocolManagerImpl::OnCreateDirectoryError, |
201 weak_ptr_factory_.GetWeakPtr())); | 201 weak_ptr_factory_.GetWeakPtr())); |
202 } | 202 } |
203 | 203 |
204 // MediaTransferProtocolManager override. | 204 // MediaTransferProtocolManager override. |
205 void ReadDirectory(const std::string& storage_handle, | 205 void ReadDirectory(const std::string& storage_handle, |
206 const uint32_t file_id, | 206 const uint32_t file_id, |
207 const size_t max_size, | 207 const size_t max_size, |
208 const ReadDirectoryCallback& callback) override { | 208 const ReadDirectoryCallback& callback) override { |
209 DCHECK(thread_checker_.CalledOnValidThread()); | 209 DCHECK(thread_checker_.CalledOnValidThread()); |
210 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 210 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
211 callback.Run(std::vector<MtpFileEntry>(), | 211 callback.Run(std::vector<MtpFileEntry>(), |
212 false /* no more entries */, | 212 false /* no more entries */, |
213 true /* error */); | 213 true /* error */); |
214 return; | 214 return; |
215 } | 215 } |
216 read_directory_callbacks_.push(callback); | 216 read_directory_callbacks_.push(callback); |
217 mtp_client_->ReadDirectoryEntryIds( | 217 mtp_client_->ReadDirectoryEntryIds( |
218 storage_handle, file_id, | 218 storage_handle, file_id, |
219 base::Bind(&MediaTransferProtocolManagerImpl:: | 219 base::Bind(&MediaTransferProtocolManagerImpl:: |
220 OnReadDirectoryEntryIdsToReadDirectory, | 220 OnReadDirectoryEntryIdsToReadDirectory, |
221 weak_ptr_factory_.GetWeakPtr(), storage_handle, max_size), | 221 weak_ptr_factory_.GetWeakPtr(), storage_handle, max_size), |
222 base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError, | 222 base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError, |
223 weak_ptr_factory_.GetWeakPtr())); | 223 weak_ptr_factory_.GetWeakPtr())); |
224 } | 224 } |
225 | 225 |
226 // MediaTransferProtocolManager override. | 226 // MediaTransferProtocolManager override. |
227 void ReadFileChunk(const std::string& storage_handle, | 227 void ReadFileChunk(const std::string& storage_handle, |
228 uint32_t file_id, | 228 uint32_t file_id, |
229 uint32_t offset, | 229 uint32_t offset, |
230 uint32_t count, | 230 uint32_t count, |
231 const ReadFileCallback& callback) override { | 231 const ReadFileCallback& callback) override { |
232 DCHECK(thread_checker_.CalledOnValidThread()); | 232 DCHECK(thread_checker_.CalledOnValidThread()); |
233 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 233 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
234 callback.Run(std::string(), true); | 234 callback.Run(std::string(), true); |
235 return; | 235 return; |
236 } | 236 } |
237 read_file_callbacks_.push(callback); | 237 read_file_callbacks_.push(callback); |
238 mtp_client_->ReadFileChunk( | 238 mtp_client_->ReadFileChunk( |
239 storage_handle, file_id, offset, count, | 239 storage_handle, file_id, offset, count, |
240 base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile, | 240 base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile, |
241 weak_ptr_factory_.GetWeakPtr()), | 241 weak_ptr_factory_.GetWeakPtr()), |
242 base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError, | 242 base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError, |
243 weak_ptr_factory_.GetWeakPtr())); | 243 weak_ptr_factory_.GetWeakPtr())); |
244 } | 244 } |
245 | 245 |
246 void GetFileInfo(const std::string& storage_handle, | 246 void GetFileInfo(const std::string& storage_handle, |
247 uint32_t file_id, | 247 uint32_t file_id, |
248 const GetFileInfoCallback& callback) override { | 248 const GetFileInfoCallback& callback) override { |
249 DCHECK(thread_checker_.CalledOnValidThread()); | 249 DCHECK(thread_checker_.CalledOnValidThread()); |
250 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 250 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
251 callback.Run(MtpFileEntry(), true); | 251 callback.Run(MtpFileEntry(), true); |
252 return; | 252 return; |
253 } | 253 } |
254 std::vector<uint32_t> file_ids; | 254 std::vector<uint32_t> file_ids; |
255 file_ids.push_back(file_id); | 255 file_ids.push_back(file_id); |
256 get_file_info_callbacks_.push(callback); | 256 get_file_info_callbacks_.push(callback); |
257 mtp_client_->GetFileInfo( | 257 mtp_client_->GetFileInfo( |
258 storage_handle, | 258 storage_handle, |
259 file_ids, | 259 file_ids, |
260 kInitialOffset, | 260 kInitialOffset, |
261 file_ids.size(), | 261 file_ids.size(), |
262 base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo, | 262 base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo, |
263 weak_ptr_factory_.GetWeakPtr()), | 263 weak_ptr_factory_.GetWeakPtr()), |
264 base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError, | 264 base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError, |
265 weak_ptr_factory_.GetWeakPtr())); | 265 weak_ptr_factory_.GetWeakPtr())); |
266 } | 266 } |
267 | 267 |
268 void RenameObject(const std::string& storage_handle, | 268 void RenameObject(const std::string& storage_handle, |
269 const uint32_t object_id, | 269 const uint32_t object_id, |
270 const std::string& new_name, | 270 const std::string& new_name, |
271 const RenameObjectCallback& callback) override { | 271 const RenameObjectCallback& callback) override { |
272 DCHECK(thread_checker_.CalledOnValidThread()); | 272 DCHECK(thread_checker_.CalledOnValidThread()); |
273 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 273 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
274 callback.Run(true /* error */); | 274 callback.Run(true /* error */); |
275 return; | 275 return; |
276 } | 276 } |
277 rename_object_callbacks_.push(callback); | 277 rename_object_callbacks_.push(callback); |
278 mtp_client_->RenameObject( | 278 mtp_client_->RenameObject( |
279 storage_handle, object_id, new_name, | 279 storage_handle, object_id, new_name, |
280 base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObject, | 280 base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObject, |
281 weak_ptr_factory_.GetWeakPtr()), | 281 weak_ptr_factory_.GetWeakPtr()), |
282 base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObjectError, | 282 base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObjectError, |
283 weak_ptr_factory_.GetWeakPtr())); | 283 weak_ptr_factory_.GetWeakPtr())); |
284 } | 284 } |
285 | 285 |
286 void CopyFileFromLocal(const std::string& storage_handle, | 286 void CopyFileFromLocal(const std::string& storage_handle, |
287 const int source_file_descriptor, | 287 const int source_file_descriptor, |
288 const uint32_t parent_id, | 288 const uint32_t parent_id, |
289 const std::string& file_name, | 289 const std::string& file_name, |
290 const CopyFileFromLocalCallback& callback) override { | 290 const CopyFileFromLocalCallback& callback) override { |
291 DCHECK(thread_checker_.CalledOnValidThread()); | 291 DCHECK(thread_checker_.CalledOnValidThread()); |
292 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 292 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
293 callback.Run(true /* error */); | 293 callback.Run(true /* error */); |
294 return; | 294 return; |
295 } | 295 } |
296 copy_file_from_local_callbacks_.push(callback); | 296 copy_file_from_local_callbacks_.push(callback); |
297 mtp_client_->CopyFileFromLocal( | 297 mtp_client_->CopyFileFromLocal( |
298 storage_handle, source_file_descriptor, parent_id, file_name, | 298 storage_handle, source_file_descriptor, parent_id, file_name, |
299 base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocal, | 299 base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocal, |
300 weak_ptr_factory_.GetWeakPtr()), | 300 weak_ptr_factory_.GetWeakPtr()), |
301 base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocalError, | 301 base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocalError, |
302 weak_ptr_factory_.GetWeakPtr())); | 302 weak_ptr_factory_.GetWeakPtr())); |
303 } | 303 } |
304 | 304 |
305 void DeleteObject(const std::string& storage_handle, | 305 void DeleteObject(const std::string& storage_handle, |
306 const uint32_t object_id, | 306 const uint32_t object_id, |
307 const DeleteObjectCallback& callback) override { | 307 const DeleteObjectCallback& callback) override { |
308 DCHECK(thread_checker_.CalledOnValidThread()); | 308 DCHECK(thread_checker_.CalledOnValidThread()); |
309 if (!ContainsKey(handles_, storage_handle) || !mtp_client_) { | 309 if (!base::ContainsKey(handles_, storage_handle) || !mtp_client_) { |
310 callback.Run(true /* error */); | 310 callback.Run(true /* error */); |
311 return; | 311 return; |
312 } | 312 } |
313 delete_object_callbacks_.push(callback); | 313 delete_object_callbacks_.push(callback); |
314 mtp_client_->DeleteObject( | 314 mtp_client_->DeleteObject( |
315 storage_handle, object_id, | 315 storage_handle, object_id, |
316 base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObject, | 316 base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObject, |
317 weak_ptr_factory_.GetWeakPtr()), | 317 weak_ptr_factory_.GetWeakPtr()), |
318 base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObjectError, | 318 base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObjectError, |
319 weak_ptr_factory_.GetWeakPtr())); | 319 weak_ptr_factory_.GetWeakPtr())); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
366 if (is_attach) | 366 if (is_attach) |
367 OnStorageAttached(storage_name); | 367 OnStorageAttached(storage_name); |
368 else | 368 else |
369 OnStorageDetached(storage_name); | 369 OnStorageDetached(storage_name); |
370 } | 370 } |
371 | 371 |
372 void OnEnumerateStorages(const std::vector<std::string>& storage_names) { | 372 void OnEnumerateStorages(const std::vector<std::string>& storage_names) { |
373 DCHECK(thread_checker_.CalledOnValidThread()); | 373 DCHECK(thread_checker_.CalledOnValidThread()); |
374 DCHECK(mtp_client_); | 374 DCHECK(mtp_client_); |
375 for (size_t i = 0; i < storage_names.size(); ++i) { | 375 for (size_t i = 0; i < storage_names.size(); ++i) { |
376 if (ContainsKey(storage_info_map_, storage_names[i])) { | 376 if (base::ContainsKey(storage_info_map_, storage_names[i])) { |
377 // OnStorageChanged() might have gotten called first. | 377 // OnStorageChanged() might have gotten called first. |
378 continue; | 378 continue; |
379 } | 379 } |
380 OnStorageAttached(storage_names[i]); | 380 OnStorageAttached(storage_names[i]); |
381 } | 381 } |
382 } | 382 } |
383 | 383 |
384 void OnGetStorageInfo(const MtpStorageInfo& storage_info) { | 384 void OnGetStorageInfo(const MtpStorageInfo& storage_info) { |
385 DCHECK(thread_checker_.CalledOnValidThread()); | 385 DCHECK(thread_checker_.CalledOnValidThread()); |
386 const std::string& storage_name = storage_info.storage_name(); | 386 const std::string& storage_name = storage_info.storage_name(); |
387 if (ContainsKey(storage_info_map_, storage_name)) { | 387 if (base::ContainsKey(storage_info_map_, storage_name)) { |
388 // This should not happen, since MediaTransferProtocolManagerImpl should | 388 // This should not happen, since MediaTransferProtocolManagerImpl should |
389 // only call EnumerateStorages() once, which populates |storage_info_map_| | 389 // only call EnumerateStorages() once, which populates |storage_info_map_| |
390 // with the already-attached devices. | 390 // with the already-attached devices. |
391 // After that, all incoming signals are either for new storage | 391 // After that, all incoming signals are either for new storage |
392 // attachments, which should not be in |storage_info_map_|, or for | 392 // attachments, which should not be in |storage_info_map_|, or for |
393 // storage detachments, which do not add to |storage_info_map_|. | 393 // storage detachments, which do not add to |storage_info_map_|. |
394 // Return to avoid giving observers phantom detach events. | 394 // Return to avoid giving observers phantom detach events. |
395 NOTREACHED(); | 395 NOTREACHED(); |
396 return; | 396 return; |
397 } | 397 } |
(...skipping 12 matching lines...) Expand all Loading... |
410 } | 410 } |
411 | 411 |
412 void OnGetStorageInfoFromDeviceError() { | 412 void OnGetStorageInfoFromDeviceError() { |
413 MtpStorageInfo info; | 413 MtpStorageInfo info; |
414 get_storage_info_from_device_callbacks_.front().Run(info, true /* error */); | 414 get_storage_info_from_device_callbacks_.front().Run(info, true /* error */); |
415 get_storage_info_from_device_callbacks_.pop(); | 415 get_storage_info_from_device_callbacks_.pop(); |
416 } | 416 } |
417 | 417 |
418 void OnOpenStorage(const std::string& handle) { | 418 void OnOpenStorage(const std::string& handle) { |
419 DCHECK(thread_checker_.CalledOnValidThread()); | 419 DCHECK(thread_checker_.CalledOnValidThread()); |
420 if (!ContainsKey(handles_, handle)) { | 420 if (!base::ContainsKey(handles_, handle)) { |
421 handles_.insert(handle); | 421 handles_.insert(handle); |
422 open_storage_callbacks_.front().Run(handle, false); | 422 open_storage_callbacks_.front().Run(handle, false); |
423 } else { | 423 } else { |
424 NOTREACHED(); | 424 NOTREACHED(); |
425 open_storage_callbacks_.front().Run(std::string(), true); | 425 open_storage_callbacks_.front().Run(std::string(), true); |
426 } | 426 } |
427 open_storage_callbacks_.pop(); | 427 open_storage_callbacks_.pop(); |
428 } | 428 } |
429 | 429 |
430 void OnOpenStorageError() { | 430 void OnOpenStorageError() { |
431 open_storage_callbacks_.front().Run(std::string(), true); | 431 open_storage_callbacks_.front().Run(std::string(), true); |
432 open_storage_callbacks_.pop(); | 432 open_storage_callbacks_.pop(); |
433 } | 433 } |
434 | 434 |
435 void OnCloseStorage() { | 435 void OnCloseStorage() { |
436 DCHECK(thread_checker_.CalledOnValidThread()); | 436 DCHECK(thread_checker_.CalledOnValidThread()); |
437 const std::string& handle = close_storage_callbacks_.front().second; | 437 const std::string& handle = close_storage_callbacks_.front().second; |
438 if (ContainsKey(handles_, handle)) { | 438 if (base::ContainsKey(handles_, handle)) { |
439 handles_.erase(handle); | 439 handles_.erase(handle); |
440 close_storage_callbacks_.front().first.Run(false); | 440 close_storage_callbacks_.front().first.Run(false); |
441 } else { | 441 } else { |
442 NOTREACHED(); | 442 NOTREACHED(); |
443 close_storage_callbacks_.front().first.Run(true); | 443 close_storage_callbacks_.front().first.Run(true); |
444 } | 444 } |
445 close_storage_callbacks_.pop(); | 445 close_storage_callbacks_.pop(); |
446 } | 446 } |
447 | 447 |
448 void OnCloseStorageError() { | 448 void OnCloseStorageError() { |
(...skipping 263 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
712 DCHECK(!g_media_transfer_protocol_manager); | 712 DCHECK(!g_media_transfer_protocol_manager); |
713 | 713 |
714 g_media_transfer_protocol_manager = | 714 g_media_transfer_protocol_manager = |
715 new MediaTransferProtocolManagerImpl(task_runner); | 715 new MediaTransferProtocolManagerImpl(task_runner); |
716 VLOG(1) << "MediaTransferProtocolManager initialized"; | 716 VLOG(1) << "MediaTransferProtocolManager initialized"; |
717 | 717 |
718 return g_media_transfer_protocol_manager; | 718 return g_media_transfer_protocol_manager; |
719 } | 719 } |
720 | 720 |
721 } // namespace device | 721 } // namespace device |
OLD | NEW |