[Media Galleries] Switch Mac MTP delegate to async interface.

webkit/fileapi/media/device_media_async_file_util.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/fileapi/media/device_media_async_file_util.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/single_thread_task_runner.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/media/filtering_file_enumerator.h"
 #include "webkit/fileapi/media/media_path_filter.h"
 #include "webkit/fileapi/media/mtp_device_async_delegate.h"
+#include "webkit/fileapi/media/mtp_device_file_system_config.h"
 #include "webkit/fileapi/media/mtp_device_map_service.h"
 
 namespace fileapi {
 
 namespace {
 
 const base::FilePath::CharType kDeviceMediaAsyncFileUtilTempDir[] =
     FILE_PATH_LITERAL("DeviceMediaFileSystem");
 
 // Returns true if the current thread is IO thread.
 bool IsOnIOThread(FileSystemOperationContext* context) {
   return context->file_system_context()->task_runners()->
       io_task_runner()->RunsTasksOnCurrentThread();
 }
 
 // Called on the IO thread.
 MTPDeviceAsyncDelegate* GetMTPDeviceDelegate(
     FileSystemOperationContext* context) {
   DCHECK(IsOnIOThread(context));
   return MTPDeviceMapService::GetInstance()->GetMTPDeviceAsyncDelegate(
       context->mtp_device_delegate_url());
 }
 
-// Called on the blocking pool thread to create a snapshot file to hold the
+// Called on a blocking pool thread to create a snapshot file to hold the
 // contents of |device_file_path|. The snapshot file is created in
 // "profile_path/kDeviceMediaAsyncFileUtilTempDir" directory. If the snapshot
 // file is created successfully, |snapshot_file_path| will be a non-empty file
 // path. In case of failure, the |snapshot_file_path| will be an empty file
 // path.
 void CreateSnapshotFileOnBlockingPool(
     const base::FilePath& device_file_path,
     const base::FilePath& profile_path,
     base::FilePath* snapshot_file_path) {
   DCHECK(snapshot_file_path);
   base::FilePath isolated_media_file_system_dir_path =
       profile_path.Append(kDeviceMediaAsyncFileUtilTempDir);
   if (!file_util::CreateDirectory(isolated_media_file_system_dir_path) ||
       !file_util::CreateTemporaryFileInDir(isolated_media_file_system_dir_path,
                                            snapshot_file_path)) {
     LOG(WARNING) << "Could not create media snapshot file "
                  << isolated_media_file_system_dir_path.value();
     *snapshot_file_path = base::FilePath();
   }
 }
 
 }  // namespace
 
 DeviceMediaAsyncFileUtil::~DeviceMediaAsyncFileUtil() {
 }
 
 // static
 DeviceMediaAsyncFileUtil* DeviceMediaAsyncFileUtil::Create(
     const base::FilePath& profile_path) {
+#if defined(USE_MTP_DEVICE_ASYNC_DELEGATE)
+  DCHECK(!profile_path.empty());
+  return new DeviceMediaAsyncFileUtil(profile_path);
+#else
   return NULL;
+#endif
 }
 
 bool DeviceMediaAsyncFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     int file_flags,
     const CreateOrOpenCallback& callback) {
   DCHECK(IsOnIOThread(context));
   NOTIMPLEMENTED();
   if (!callback.is_null()) {
@@ skipping 257 matching lines @@
       *snapshot_file_path,
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback),
       base::Bind(&DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 }  // namespace fileapi