Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

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"
 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_device_async_delegate.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_device_map_service.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_file_stream_reader.h"
 #include "chrome/browser/media_galleries/fileapi/native_media_file_util.h"
 #include "chrome/browser/media_galleries/fileapi/readahead_file_stream_reader.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/native_file_util.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
-using fileapi::AsyncFileUtil;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
-using webkit_blob::ShareableFileReference;
+using storage::AsyncFileUtil;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
+using storage::ShareableFileReference;
 
 namespace {
 
 const char kDeviceMediaAsyncFileUtilTempDir[] = "DeviceMediaFileSystem";
 
 MTPDeviceAsyncDelegate* GetMTPDeviceDelegate(const FileSystemURL& url) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   return MTPDeviceMapService::GetInstance()->GetMTPDeviceAsyncDelegate(
       url.filesystem_id());
 }
@@ skipping 58 matching lines @@
     snapshot_file_path = base::FilePath();
   }
   return snapshot_file_path;
 }
 
 // Called after OnDidCreateSnapshotFile finishes media check.
 // |callback| is invoked to complete the CreateSnapshotFile request.
 void OnDidCheckMediaForCreateSnapshotFile(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     const base::File::Info& file_info,
-    scoped_refptr<webkit_blob::ShareableFileReference> platform_file,
+    scoped_refptr<storage::ShareableFileReference> platform_file,
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   base::FilePath platform_path(platform_file.get()->path());
   if (error != base::File::FILE_OK)
     platform_file = NULL;
   callback.Run(error, file_info, platform_path, platform_file);
 }
 
 // Called when the snapshot file specified by the |platform_path| is
 // successfully created. |file_info| contains the device media file details
 // for which the snapshot file is created.
 void OnDidCreateSnapshotFile(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     base::SequencedTaskRunner* media_task_runner,
     bool validate_media_files,
     const base::File::Info& file_info,
     const base::FilePath& platform_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  scoped_refptr<webkit_blob::ShareableFileReference> file =
+  scoped_refptr<storage::ShareableFileReference> file =
       ShareableFileReference::GetOrCreate(
           platform_path,
           ShareableFileReference::DELETE_ON_FINAL_RELEASE,
           media_task_runner);
 
   if (validate_media_files) {
     base::PostTaskAndReplyWithResult(
         media_task_runner,
         FROM_HERE,
         base::Bind(&NativeMediaFileUtil::IsMediaFile, platform_path),
@@ skipping 80 matching lines @@
 }
 
 DeviceMediaAsyncFileUtil::MediaPathFilterWrapper::~MediaPathFilterWrapper() {
 }
 
 AsyncFileUtil::EntryList
 DeviceMediaAsyncFileUtil::MediaPathFilterWrapper::FilterMediaEntries(
     const AsyncFileUtil::EntryList& file_list) {
   AsyncFileUtil::EntryList results;
   for (size_t i = 0; i < file_list.size(); ++i) {
-    const fileapi::DirectoryEntry& entry = file_list[i];
+    const storage::DirectoryEntry& entry = file_list[i];
     if (entry.is_directory || CheckFilePath(base::FilePath(entry.name))) {
       results.push_back(entry);
     }
   }
   return results;
 }
 
 bool DeviceMediaAsyncFileUtil::MediaPathFilterWrapper::CheckFilePath(
     const base::FilePath& path) {
   return media_path_filter_->Match(path);
 }
 
 DeviceMediaAsyncFileUtil::~DeviceMediaAsyncFileUtil() {
 }
 
 // static
 scoped_ptr<DeviceMediaAsyncFileUtil> DeviceMediaAsyncFileUtil::Create(
     const base::FilePath& profile_path,
     MediaFileValidationType validation_type) {
   DCHECK(!profile_path.empty());
   return make_scoped_ptr(
       new DeviceMediaAsyncFileUtil(profile_path, validation_type));
 }
 
 bool DeviceMediaAsyncFileUtil::SupportsStreaming(
-    const fileapi::FileSystemURL& url) {
+    const storage::FileSystemURL& url) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate)
     return false;
   return delegate->IsStreaming();
 }
 
 void DeviceMediaAsyncFileUtil::CreateOrOpen(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
@@ skipping 171 matching lines @@
       task_runner,
       FROM_HERE,
       base::Bind(&CreateSnapshotFileOnBlockingPool, url.path(), profile_path_),
       base::Bind(&OnSnapshotFileCreatedRunTask,
                  base::Passed(&context),
                  callback,
                  url,
                  validate_media_files()));
 }
 
-scoped_ptr<webkit_blob::FileStreamReader>
+scoped_ptr<storage::FileStreamReader>
 DeviceMediaAsyncFileUtil::GetFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
-    fileapi::FileSystemContext* context) {
+    storage::FileSystemContext* context) {
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate)
-    return scoped_ptr<webkit_blob::FileStreamReader>();
+    return scoped_ptr<storage::FileStreamReader>();
 
   DCHECK(delegate->IsStreaming());
-  return scoped_ptr<webkit_blob::FileStreamReader>(
-      new ReadaheadFileStreamReader(
-          new MTPFileStreamReader(context,
-                                  url,
-                                  offset,
-                                  expected_modification_time,
-                                  validate_media_files())));
+  return scoped_ptr<storage::FileStreamReader>(new ReadaheadFileStreamReader(
+      new MTPFileStreamReader(context,
+                              url,
+                              offset,
+                              expected_modification_time,
+                              validate_media_files())));
 }
 
 DeviceMediaAsyncFileUtil::DeviceMediaAsyncFileUtil(
     const base::FilePath& profile_path,
     MediaFileValidationType validation_type)
     : profile_path_(profile_path),
       weak_ptr_factory_(this) {
   if (validation_type == APPLY_MEDIA_FILE_VALIDATION) {
     media_path_filter_wrapper_ = new MediaPathFilterWrapper;
   }
@@ skipping 35 matching lines @@
       FROM_HERE,
       base::Bind(&MediaPathFilterWrapper::FilterMediaEntries,
                  media_path_filter_wrapper_,
                  file_list),
       base::Bind(&OnDidCheckMediaForReadDirectory, callback, has_more));
 }
 
 bool DeviceMediaAsyncFileUtil::validate_media_files() const {
   return media_path_filter_wrapper_.get() != NULL;
 }