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

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.cc

 // Copyright 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/chromeos/extensions/file_manager/private_api_file_system.h"
 
 #include <sys/statvfs.h>
 
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/file_browser_private.h"
 #include "chrome/common/extensions/api/file_browser_private_internal.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
-#include "webkit/browser/fileapi/file_system_context.h"
-#include "webkit/browser/fileapi/file_system_file_util.h"
-#include "webkit/browser/fileapi/file_system_operation_context.h"
-#include "webkit/browser/fileapi/file_system_operation_runner.h"
-#include "webkit/browser/fileapi/file_system_url.h"
-#include "webkit/common/fileapi/file_system_info.h"
-#include "webkit/common/fileapi/file_system_types.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_file_util.h"
+#include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/browser/fileapi/file_system_operation_runner.h"
+#include "storage/browser/fileapi/file_system_url.h"
+#include "storage/common/fileapi/file_system_info.h"
+#include "storage/common/fileapi/file_system_types.h"
+#include "storage/common/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using file_manager::util::EntryDefinition;
 using file_manager::util::FileDefinition;
-using fileapi::FileSystemURL;
+using storage::FileSystemURL;
 
 namespace extensions {
 namespace {
 
 // Retrieves total and remaining available size on |mount_path|.
 void GetSizeStatsOnBlockingPool(const std::string& mount_path,
                                 uint64* total_size,
                                 uint64* remaining_size) {
   struct statvfs stat = {};  // Zero-clear
   if (HANDLE_EINTR(statvfs(mount_path.c_str(), &stat)) == 0) {
@@ skipping 24 matching lines @@
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return NULL;
 
   return file_manager::FileBrowserPrivateAPI::Get(profile)->event_router();
 }
 
 // Notifies the copy progress to extensions via event router.
 void NotifyCopyProgress(
     void* profile_id,
-    fileapi::FileSystemOperationRunner::OperationID operation_id,
-    fileapi::FileSystemOperation::CopyProgressType type,
+    storage::FileSystemOperationRunner::OperationID operation_id,
+    storage::FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     int64 size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   file_manager::EventRouter* event_router =
       GetEventRouterByProfileId(profile_id);
   if (event_router) {
     event_router->OnCopyProgress(
         operation_id, type,
         source_url.ToGURL(), destination_url.ToGURL(), size);
   }
 }
 
 // Callback invoked periodically on progress update of Copy().
 void OnCopyProgress(
     void* profile_id,
-    fileapi::FileSystemOperationRunner::OperationID* operation_id,
-    fileapi::FileSystemOperation::CopyProgressType type,
+    storage::FileSystemOperationRunner::OperationID* operation_id,
+    storage::FileSystemOperation::CopyProgressType type,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     int64 size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyCopyProgress,
                  profile_id, *operation_id, type,
                  source_url, destination_url, size));
 }
 
 // Notifies the copy completion to extensions via event router.
 void NotifyCopyCompletion(
     void* profile_id,
-    fileapi::FileSystemOperationRunner::OperationID operation_id,
+    storage::FileSystemOperationRunner::OperationID operation_id,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     base::File::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   file_manager::EventRouter* event_router =
       GetEventRouterByProfileId(profile_id);
   if (event_router)
     event_router->OnCopyCompleted(
         operation_id,
         source_url.ToGURL(), destination_url.ToGURL(), error);
 }
 
 // Callback invoked upon completion of Copy() (regardless of succeeded or
 // failed).
 void OnCopyCompleted(
     void* profile_id,
-    fileapi::FileSystemOperationRunner::OperationID* operation_id,
+    storage::FileSystemOperationRunner::OperationID* operation_id,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url,
     base::File::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyCopyCompletion,
                  profile_id, *operation_id,
                  source_url, destination_url, error));
 }
 
 // Starts the copy operation via FileSystemOperationRunner.
-fileapi::FileSystemOperationRunner::OperationID StartCopyOnIOThread(
+storage::FileSystemOperationRunner::OperationID StartCopyOnIOThread(
     void* profile_id,
-    scoped_refptr<fileapi::FileSystemContext> file_system_context,
+    scoped_refptr<storage::FileSystemContext> file_system_context,
     const FileSystemURL& source_url,
     const FileSystemURL& destination_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Note: |operation_id| is owned by the callback for
   // FileSystemOperationRunner::Copy(). It is always called in the next message
   // loop or later, so at least during this invocation it should alive.
-  fileapi::FileSystemOperationRunner::OperationID* operation_id =
-      new fileapi::FileSystemOperationRunner::OperationID;
+  storage::FileSystemOperationRunner::OperationID* operation_id =
+      new storage::FileSystemOperationRunner::OperationID;
   *operation_id = file_system_context->operation_runner()->Copy(
-      source_url, destination_url,
-      fileapi::FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED,
-      base::Bind(&OnCopyProgress,
-                 profile_id, base::Unretained(operation_id)),
+      source_url,
+      destination_url,
+      storage::FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED,
+      base::Bind(&OnCopyProgress, profile_id, base::Unretained(operation_id)),
       base::Bind(&OnCopyCompleted,
-                 profile_id, base::Owned(operation_id),
-                 source_url, destination_url));
+                 profile_id,
+                 base::Owned(operation_id),
+                 source_url,
+                 destination_url));
   return *operation_id;
 }
 
 void OnCopyCancelled(base::File::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // We just ignore the status if the copy is actually cancelled or not,
   // because failing cancellation means the operation is not running now.
   DLOG_IF(WARNING, error != base::File::FILE_OK)
       << "Failed to cancel copy: " << error;
 }
 
 // Cancels the running copy operation identified by |operation_id|.
 void CancelCopyOnIOThread(
-    scoped_refptr<fileapi::FileSystemContext> file_system_context,
-    fileapi::FileSystemOperationRunner::OperationID operation_id) {
+    scoped_refptr<storage::FileSystemContext> file_system_context,
+    storage::FileSystemOperationRunner::OperationID operation_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   file_system_context->operation_runner()->Cancel(
       operation_id, base::Bind(&OnCopyCancelled));
 }
 
 }  // namespace
 
 void FileBrowserPrivateRequestFileSystemFunction::DidFail(
     base::File::Error error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetError(base::StringPrintf("File error %d", static_cast<int>(error_code)));
   SendResponse(false);
 }
 
-bool FileBrowserPrivateRequestFileSystemFunction::
-    SetupFileSystemAccessPermissions(
-        scoped_refptr<fileapi::FileSystemContext> file_system_context,
-        int child_id,
-        Profile* profile,
-        scoped_refptr<const extensions::Extension> extension) {
+bool
+FileBrowserPrivateRequestFileSystemFunction::SetupFileSystemAccessPermissions(
+    scoped_refptr<storage::FileSystemContext> file_system_context,
+    int child_id,
+    Profile* profile,
+    scoped_refptr<const extensions::Extension> extension) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!extension.get())
     return false;
 
   // Make sure that only component extension can access the entire
   // local file system.
   if (extension_->location() != extensions::Manifest::COMPONENT) {
     NOTREACHED() << "Private method access by non-component extension "
                  << extension->id();
     return false;
   }
 
-  fileapi::ExternalFileSystemBackend* backend =
+  storage::ExternalFileSystemBackend* backend =
       file_system_context->external_backend();
   if (!backend)
     return false;
 
   // Grant full access to File API from this component extension.
   backend->GrantFullAccessToExtension(extension_->id());
 
   // Grant R/W file permissions to the renderer hosting component
   // extension for all paths exposed by our local file system backend.
   std::vector<base::FilePath> root_dirs = backend->GetRootDirectories();
@@ skipping 34 matching lines @@
   VolumeManager* volume_manager = VolumeManager::Get(GetProfile());
   if (!volume_manager)
     return false;
 
   VolumeInfo volume_info;
   if (!volume_manager->FindVolumeInfoById(params->volume_id, &volume_info)) {
     DidFail(base::File::FILE_ERROR_NOT_FOUND);
     return false;
   }
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   // Set up file permission access.
   const int child_id = render_view_host()->GetProcess()->GetID();
   if (!SetupFileSystemAccessPermissions(
           file_system_context, child_id, GetProfile(), extension())) {
     DidFail(base::File::FILE_ERROR_SECURITY);
     return false;
   }
@@ skipping 52 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   // First param is url of a file to watch.
   std::string url;
   if (!args_->GetString(0, &url) || url.empty())
     return false;
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   FileSystemURL file_watch_url = file_system_context->CrackURL(GURL(url));
   base::FilePath local_path = file_watch_url.path();
   base::FilePath virtual_path = file_watch_url.virtual_path();
   if (local_path.empty()) {
     Respond(false);
     return true;
   }
@@ skipping 102 matching lines @@
   sizes->SetDouble("remainingSize", static_cast<double>(*remaining_size));
 
   SendResponse(true);
 }
 
 bool FileBrowserPrivateValidatePathNameLengthFunction::RunAsync() {
   using extensions::api::file_browser_private::ValidatePathNameLength::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
-  fileapi::FileSystemURL filesystem_url(
+  storage::FileSystemURL filesystem_url(
       file_system_context->CrackURL(GURL(params->parent_directory_url)));
   if (!chromeos::FileSystemBackend::CanHandleURL(filesystem_url))
     return false;
 
   // No explicit limit on the length of Drive file names.
-  if (filesystem_url.type() == fileapi::kFileSystemTypeDrive) {
+  if (filesystem_url.type() == storage::kFileSystemTypeDrive) {
     SetResult(new base::FundamentalValue(true));
     SendResponse(true);
     return true;
   }
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&GetFileNameMaxLengthOnBlockingPool,
                  filesystem_url.path().AsUTF8Unsafe()),
@@ skipping 38 matching lines @@
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (params->source_url.empty() || params->parent.empty() ||
       params->new_name.empty()) {
     // Error code in format of DOMError.name.
     SetError("EncodingError");
     return false;
   }
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   // |parent| may have a trailing slash if it is a root directory.
   std::string destination_url_string = params->parent;
   if (destination_url_string[destination_url_string.size() - 1] != '/')
     destination_url_string += '/';
   destination_url_string += net::EscapePath(params->new_name);
 
-  fileapi::FileSystemURL source_url(
+  storage::FileSystemURL source_url(
       file_system_context->CrackURL(GURL(params->source_url)));
-  fileapi::FileSystemURL destination_url(
+  storage::FileSystemURL destination_url(
       file_system_context->CrackURL(GURL(destination_url_string)));
 
   if (!source_url.is_valid() || !destination_url.is_valid()) {
     // Error code in format of DOMError.name.
     SetError("EncodingError");
     return false;
   }
 
   return BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::IO,
@@ skipping 15 matching lines @@
   SendResponse(true);
 }
 
 bool FileBrowserPrivateCancelCopyFunction::RunAsync() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   using extensions::api::file_browser_private::CancelCopy::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
 
   // We don't much take care about the result of cancellation.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&CancelCopyOnIOThread, file_system_context, params->copy_id));
   SendResponse(true);
   return true;
 }
 
 bool FileBrowserPrivateInternalResolveIsolatedEntriesFunction::RunAsync() {
   using extensions::api::file_browser_private_internal::ResolveIsolatedEntries::
       Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+  scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderViewHost(
           GetProfile(), render_view_host());
   DCHECK(file_system_context);
 
-  const fileapi::ExternalFileSystemBackend* external_backend =
+  const storage::ExternalFileSystemBackend* external_backend =
       file_system_context->external_backend();
   DCHECK(external_backend);
 
   file_manager::util::FileDefinitionList file_definition_list;
   for (size_t i = 0; i < params->urls.size(); ++i) {
     FileSystemURL fileSystemUrl =
         file_system_context->CrackURL(GURL(params->urls[i]));
     DCHECK(external_backend->CanHandleType(fileSystemUrl.type()));
 
     FileDefinition file_definition;
@@ skipping 37 matching lines @@
         "/" + entry_definition_list->at(i).full_path.AsUTF8Unsafe();
     entry->file_is_directory = entry_definition_list->at(i).is_directory;
     entries.push_back(entry);
   }
 
   results_ = extensions::api::file_browser_private_internal::
       ResolveIsolatedEntries::Results::Create(entries);
   SendResponse(true);
 }
 }  // namespace extensions