No media-file validation mode for DeviceMediaAsyncUtil.

chrome/browser/media_galleries/fileapi/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 "chrome/browser/media_galleries/fileapi/device_media_async_file_util.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
@@ skipping 46 matching lines @@
   return snapshot_file_path;
 }
 
 }  // namespace
 
 DeviceMediaAsyncFileUtil::~DeviceMediaAsyncFileUtil() {
 }
 
 // static
 DeviceMediaAsyncFileUtil* DeviceMediaAsyncFileUtil::Create(
-    const base::FilePath& profile_path) {
+    const base::FilePath& profile_path,
+    MediaFileValidationType validation_type) {
   DCHECK(!profile_path.empty());
-  return new DeviceMediaAsyncFileUtil(profile_path);
+  return new DeviceMediaAsyncFileUtil(profile_path, validation_type);
 }
 
 bool DeviceMediaAsyncFileUtil::SupportsStreaming(
     const fileapi::FileSystemURL& url) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate)
     return false;
   return delegate->IsStreaming();
 }
@@ skipping 196 matching lines @@
     int64 offset,
     const base::Time& expected_modification_time,
     fileapi::FileSystemContext* context) {
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate)
     return scoped_ptr<webkit_blob::FileStreamReader>();
 
   DCHECK(delegate->IsStreaming());
   return scoped_ptr<webkit_blob::FileStreamReader>(
       new ReadaheadFileStreamReader(new MTPFileStreamReader(
-          context, url, offset, expected_modification_time)));
+          context, url, offset, expected_modification_time,
+          validation_type_ == APPLY_MEDIA_FILE_VALIDATION)));
 }
 
 DeviceMediaAsyncFileUtil::DeviceMediaAsyncFileUtil(
-    const base::FilePath& profile_path)
+    const base::FilePath& profile_path,
+    MediaFileValidationType validation_type)
     : profile_path_(profile_path),
+      validation_type_(validation_type),
       weak_ptr_factory_(this) {
 }
 
 void DeviceMediaAsyncFileUtil::OnDidGetFileInfo(
     const AsyncFileUtil::GetFileInfoCallback& callback,
     const base::File::Info& file_info) {
   callback.Run(base::File::FILE_OK, file_info);
 }
 
 void DeviceMediaAsyncFileUtil::OnGetFileInfoError(
@@ skipping 13 matching lines @@
     const AsyncFileUtil::ReadDirectoryCallback& callback,
     base::File::Error error) {
   callback.Run(error, AsyncFileUtil::EntryList(), false /*no more*/);
 }
 
 void DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     base::SequencedTaskRunner* media_task_runner,
     const base::File::Info& file_info,
     const base::FilePath& platform_path) {
-  base::PostTaskAndReplyWithResult(
-      media_task_runner,
-      FROM_HERE,
-      base::Bind(&NativeMediaFileUtil::IsMediaFile, platform_path),
-      base::Bind(&DeviceMediaAsyncFileUtil::OnDidCheckMedia,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback,
-                 file_info,
-                 ShareableFileReference::GetOrCreate(
-                     platform_path,
-                     ShareableFileReference::DELETE_ON_FINAL_RELEASE,
-                     media_task_runner)));
+  scoped_refptr<webkit_blob::ShareableFileReference> file =
+      ShareableFileReference::GetOrCreate(
+                             platform_path,
+                             ShareableFileReference::DELETE_ON_FINAL_RELEASE,
+                             media_task_runner);
+
+  if (validation_type_ == APPLY_MEDIA_FILE_VALIDATION) {
+    base::PostTaskAndReplyWithResult(
+        media_task_runner,
+        FROM_HERE,
+        base::Bind(&NativeMediaFileUtil::IsMediaFile, platform_path),
+        base::Bind(&DeviceMediaAsyncFileUtil::OnDidCheckMedia,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   callback,
+                   file_info,
+                   file));
+  } else {
+    OnDidCheckMedia(callback, file_info, file, base::File::FILE_OK);
+  }
 }
 
 void DeviceMediaAsyncFileUtil::OnDidCheckMedia(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     const base::File::Info& file_info,
     scoped_refptr<webkit_blob::ShareableFileReference> platform_file,
     base::File::Error error) {
   base::FilePath platform_path(platform_file.get()->path());
   if (error != base::File::FILE_OK)
     platform_file = NULL;
@@ skipping 26 matching lines @@
       url.path(),  // device file path
       snapshot_file_path,
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  make_scoped_refptr(context->task_runner())),
       base::Bind(&DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }