Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(30)

Side by Side Diff: device/media_transfer_protocol/media_transfer_protocol_manager.cc

Issue 2230083003: device: Use stl utilities from the base namespace (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebased Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « device/hid/hid_service_mac.cc ('k') | device/nfc/nfc_adapter.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
OLDNEW
« no previous file with comments | « device/hid/hid_service_mac.cc ('k') | device/nfc/nfc_adapter.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698