Have media gallery (through native media file util) use MIME sniffer

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"
+#include "webkit/fileapi/media/native_media_file_util.h"
+#include "webkit/fileapi/native_file_util.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) {
@@ skipping 24 matching lines @@
       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();
   }
 }
 
+void CheckMediaFile(
+    const base::FilePath& file_path,
+    base::PlatformFileError* p_error) {

[vandebo (ex-Chrome), 2013/03/29 21:53:20]

nit: error, not p_error in all your change.

[Kevin Bailey, 2013/04/03 18:05:07]

Done.

+  *p_error = NativeMediaFileUtil::IsMediaFile(file_path);
+  if (*p_error == base::PLATFORM_FILE_ERROR_SECURITY)
+    // It exists but we reject it. Try to clean up.
+    NativeFileUtil::DeleteFile(file_path);
+}
+
 }  // namespace
 
 DeviceMediaAsyncFileUtil::~DeviceMediaAsyncFileUtil() {
 }
 
 // static
 DeviceMediaAsyncFileUtil* DeviceMediaAsyncFileUtil::Create(
     const base::FilePath& profile_path) {
 #if defined(USE_MTP_DEVICE_ASYNC_DELEGATE)
   DCHECK(!profile_path.empty());
@@ skipping 228 matching lines @@
 }
 
 void DeviceMediaAsyncFileUtil::OnReadDirectoryError(
     const AsyncFileUtil::ReadDirectoryCallback& callback,
     base::PlatformFileError error) {
   if (!callback.is_null())
     callback.Run(error, AsyncFileUtil::EntryList(), false /*no more*/);
 }
 
 void DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile(
+    FileSystemOperationContext* context,
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& platform_path) {
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_OK, file_info, platform_path,
-                 kSnapshotFileTemporary);
+  base::PlatformFileError* p_error = new base::PlatformFileError;
+  context->file_system_context()->task_runners()->media_task_runner()->
+      PostTaskAndReply(
+          FROM_HERE,
+          base::Bind(&CheckMediaFile, platform_path,
+                     base::Unretained(p_error)),
+          base::Bind(&DeviceMediaAsyncFileUtil::OnDidCheckMediaRunTask,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     callback, file_info, platform_path,
+                     base::Owned(p_error)));
+}
+
+void DeviceMediaAsyncFileUtil::OnDidCheckMediaRunTask(
+    const AsyncFileUtil::CreateSnapshotFileCallback& callback,
+    const base::PlatformFileInfo& file_info,
+    const base::FilePath& platform_path,
+    base::PlatformFileError* p_error) {
+  if (!callback.is_null()) {
+    callback.Run(*p_error, file_info, platform_path, kSnapshotFileTemporary);
+  }
 }
 
 void DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     base::PlatformFileError error) {
   if (!callback.is_null())
     callback.Run(error, base::PlatformFileInfo(), base::FilePath(),
                  kSnapshotFileTemporary);
 }
 
@@ skipping 10 matching lines @@
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context);
   if (!delegate) {
     OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
   delegate->CreateSnapshotFile(
       device_file_path,
       *snapshot_file_path,
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile,
                  weak_ptr_factory_.GetWeakPtr(),
+                 context,
                  callback),
       base::Bind(&DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 }  // namespace fileapi