Move storage-related files from webkit/ to new top-level directory storage/

chrome/browser/media_galleries/win/mtp_device_delegate_impl_win.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.
 //
 // MTPDeviceDelegateImplWin implementation.
 
 #include "chrome/browser/media_galleries/win/mtp_device_delegate_impl_win.h"
 
 #include <portabledevice.h>
 
@@ skipping 11 matching lines @@
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/browser/media_galleries/win/mtp_device_object_entry.h"
 #include "chrome/browser/media_galleries/win/mtp_device_object_enumerator.h"
 #include "chrome/browser/media_galleries/win/mtp_device_operations_util.h"
 #include "chrome/browser/media_galleries/win/portable_device_map_service.h"
 #include "chrome/browser/media_galleries/win/snapshot_file_details.h"
 #include "components/storage_monitor/storage_monitor.h"
 #include "content/public/browser/browser_thread.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/common/fileapi/file_system_util.h"
 
 namespace {
 
 // Gets the details of the MTP partition storage specified by the
 // |storage_path| on the UI thread. Returns true if the storage details are
 // valid and returns false otherwise.
 bool GetStorageInfoOnUIThread(const base::string16& storage_path,
                               base::string16* pnp_device_id,
                               base::string16* storage_object_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 130 matching lines @@
                                                    file_info);
 }
 
 // Reads the |root| directory file entries on a blocking pool thread. On
 // success, |error| is set to base::File::FILE_OK and |entries| contains the
 // directory file entries. On failure, |error| is set to platform file error
 // and |entries| is not set.
 base::File::Error ReadDirectoryOnBlockingPoolThread(
     const MTPDeviceDelegateImplWin::StorageDeviceInfo& device_info,
     const base::FilePath& root,
-    fileapi::AsyncFileUtil::EntryList* entries) {
+    storage::AsyncFileUtil::EntryList* entries) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!root.empty());
   DCHECK(entries);
   base::File::Info file_info;
   base::File::Error error = GetFileInfoOnBlockingPoolThread(device_info, root,
                                                             &file_info);
   if (error != base::File::FILE_OK)
     return error;
 
   if (!file_info.is_directory)
     return base::File::FILE_ERROR_NOT_A_DIRECTORY;
 
   base::FilePath current;
   scoped_ptr<MTPDeviceObjectEnumerator> file_enum =
       CreateFileEnumeratorOnBlockingPoolThread(device_info, root);
   if (!file_enum)
     return error;
 
   while (!(current = file_enum->Next()).empty()) {
-    fileapi::DirectoryEntry entry;
+    storage::DirectoryEntry entry;
     entry.is_directory = file_enum->IsDirectory();
-    entry.name = fileapi::VirtualPath::BaseName(current).value();
+    entry.name = storage::VirtualPath::BaseName(current).value();
     entry.size = file_enum->Size();
     entry.last_modified_time = file_enum->LastModifiedTime();
     entries->push_back(entry);
   }
   return error;
 }
 
 // Gets the device file stream object on a blocking pool thread.
 // |device_info| contains the device storage partition details.
 // On success, returns base::File::FILE_OK and file stream details are set in
@@ skipping 179 matching lines @@
                                  error_callback,
                                  base::Owned(file_info))));
 }
 
 void MTPDeviceDelegateImplWin::ReadDirectory(
     const base::FilePath& root,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!root.empty());
-  fileapi::AsyncFileUtil::EntryList* entries =
-      new fileapi::AsyncFileUtil::EntryList;
+  storage::AsyncFileUtil::EntryList* entries =
+      new storage::AsyncFileUtil::EntryList;
   EnsureInitAndRunTask(
       PendingTaskInfo(FROM_HERE,
                       base::Bind(&ReadDirectoryOnBlockingPoolThread,
                                  storage_device_info_,
                                  root,
                                  base::Unretained(entries)),
                       base::Bind(&MTPDeviceDelegateImplWin::OnDidReadDirectory,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  success_callback,
                                  error_callback,
@@ skipping 122 matching lines @@
     success_callback.Run(*file_info);
   else
     error_callback.Run(error);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplWin::OnDidReadDirectory(
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
-    fileapi::AsyncFileUtil::EntryList* file_list,
+    storage::AsyncFileUtil::EntryList* file_list,
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(file_list);
   if (error == base::File::FILE_OK)
     success_callback.Run(*file_list, false /*no more entries*/);
   else
     error_callback.Run(error);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
@@ skipping 54 matching lines @@
         current_snapshot_details_->file_info(),
         current_snapshot_details_->request_info().snapshot_file_path);
   } else {
     current_snapshot_details_->request_info().error_callback.Run(
         base::File::FILE_ERROR_FAILED);
   }
   task_in_progress_ = false;
   current_snapshot_details_.reset();
   ProcessNextPendingRequest();
 }