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

chrome/browser/extensions/api/developer_private/developer_private_api.cc

 // Copyright (c) 2012 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/extensions/api/developer_private/developer_private_api.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
 #include "apps/saved_files_service.h"
@@ skipping 55 matching lines @@
 #include "extensions/common/manifest_handlers/offline_enabled_info.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
-#include "webkit/browser/fileapi/external_mount_points.h"
-#include "webkit/browser/fileapi/file_system_context.h"
-#include "webkit/browser/fileapi/file_system_operation.h"
-#include "webkit/browser/fileapi/file_system_operation_runner.h"
-#include "webkit/browser/fileapi/isolated_context.h"
-#include "webkit/common/blob/shareable_file_reference.h"
+#include "storage/browser/fileapi/external_mount_points.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_operation.h"
+#include "storage/browser/fileapi/file_system_operation_runner.h"
+#include "storage/browser/fileapi/isolated_context.h"
+#include "storage/common/blob/shareable_file_reference.h"
 
 using apps::AppWindow;
 using apps::AppWindowRegistry;
 using content::RenderViewHost;
 
 namespace extensions {
 
 namespace developer_private = api::developer_private;
 
 namespace {
@@ skipping 973 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &directory_url_str));
 
   context_ = content::BrowserContext::GetStoragePartition(
       GetProfile(), render_view_host()->GetSiteInstance())
                  ->GetFileSystemContext();
 
   // Directory url is non empty only for syncfilesystem.
   if (directory_url_str != "") {
-    fileapi::FileSystemURL directory_url =
+    storage::FileSystemURL directory_url =
         context_->CrackURL(GURL(directory_url_str));
     if (!directory_url.is_valid() ||
-        directory_url.type() != fileapi::kFileSystemTypeSyncable) {
+        directory_url.type() != storage::kFileSystemTypeSyncable) {
       SetError("DirectoryEntry of unsupported filesystem.");
       return false;
     }
     return LoadByFileSystemAPI(directory_url);
   } else {
     // Check if the DirecotryEntry is the instance of chrome filesystem.
     if (!app_file_handler_util::ValidateFileEntryAndGetPath(filesystem_name,
                                                             filesystem_path,
                                                             render_view_host_,
                                                             &project_base_path_,
                                                             &error_)) {
       SetError("DirectoryEntry of unsupported filesystem.");
       return false;
     }
 
     // Try to load using the FileSystem API backend, in case the filesystem
     // points to a non-native local directory.
     std::string filesystem_id;
     bool cracked =
-        fileapi::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id);
+        storage::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id);
     CHECK(cracked);
     base::FilePath virtual_path =
-        fileapi::IsolatedContext::GetInstance()
+        storage::IsolatedContext::GetInstance()
             ->CreateVirtualRootPath(filesystem_id)
             .Append(base::FilePath::FromUTF8Unsafe(filesystem_path));
-    fileapi::FileSystemURL directory_url = context_->CreateCrackedFileSystemURL(
+    storage::FileSystemURL directory_url = context_->CreateCrackedFileSystemURL(
         extensions::Extension::GetBaseURLFromExtensionId(extension_id()),
-        fileapi::kFileSystemTypeIsolated,
+        storage::kFileSystemTypeIsolated,
         virtual_path);
 
     if (directory_url.is_valid() &&
-        directory_url.type() != fileapi::kFileSystemTypeNativeLocal &&
-        directory_url.type() != fileapi::kFileSystemTypeRestrictedNativeLocal &&
-        directory_url.type() != fileapi::kFileSystemTypeDragged) {
+        directory_url.type() != storage::kFileSystemTypeNativeLocal &&
+        directory_url.type() != storage::kFileSystemTypeRestrictedNativeLocal &&
+        directory_url.type() != storage::kFileSystemTypeDragged) {
       return LoadByFileSystemAPI(directory_url);
     }
 
     Load();
   }
 
   return true;
 }
 
 bool DeveloperPrivateLoadDirectoryFunction::LoadByFileSystemAPI(
-    const fileapi::FileSystemURL& directory_url) {
+    const storage::FileSystemURL& directory_url) {
   std::string directory_url_str = directory_url.ToGURL().spec();
 
   size_t pos = 0;
   // Parse the project directory name from the project url. The project url is
   // expected to have project name as the suffix.
   if ((pos = directory_url_str.rfind("/")) == std::string::npos) {
     SetError("Invalid Directory entry.");
     return false;
   }
 
@@ skipping 37 matching lines @@
   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
       base::Bind(&DeveloperPrivateLoadDirectoryFunction::
                  ReadDirectoryByFileSystemAPI,
                  this, project_path, project_path.BaseName()));
 }
 
 void DeveloperPrivateLoadDirectoryFunction::ReadDirectoryByFileSystemAPI(
     const base::FilePath& project_path,
     const base::FilePath& destination_path) {
   GURL project_url = GURL(project_base_url_ + destination_path.AsUTF8Unsafe());
-  fileapi::FileSystemURL url = context_->CrackURL(project_url);
+  storage::FileSystemURL url = context_->CrackURL(project_url);
 
   context_->operation_runner()->ReadDirectory(
       url, base::Bind(&DeveloperPrivateLoadDirectoryFunction::
                       ReadDirectoryByFileSystemAPICb,
                       this, project_path, destination_path));
 }
 
 void DeveloperPrivateLoadDirectoryFunction::ReadDirectoryByFileSystemAPICb(
     const base::FilePath& project_path,
     const base::FilePath& destination_path,
     base::File::Error status,
-    const fileapi::FileSystemOperation::FileEntryList& file_list,
+    const storage::FileSystemOperation::FileEntryList& file_list,
     bool has_more) {
-
   if (status != base::File::FILE_OK) {
     DLOG(ERROR) << "Error in copying files from sync filesystem.";
     return;
   }
 
   // We add 1 to the pending copy operations for both files and directories. We
   // release the directory copy operation once all the files under the directory
   // are added for copying. We do that to ensure that pendingCopyOperationsCount
   // does not become zero before all copy operations are finished.
   // In case the directory happens to be executing the last copy operation it
   // will call SendResponse to send the response to the API. The pending copy
   // operations of files are released by the CopyFile function.
   pending_copy_operations_count_ += file_list.size();
 
   for (size_t i = 0; i < file_list.size(); ++i) {
     if (file_list[i].is_directory) {
       ReadDirectoryByFileSystemAPI(project_path.Append(file_list[i].name),
                                    destination_path.Append(file_list[i].name));
       continue;
     }
 
     GURL project_url = GURL(project_base_url_ +
         destination_path.Append(file_list[i].name).AsUTF8Unsafe());
-    fileapi::FileSystemURL url = context_->CrackURL(project_url);
+    storage::FileSystemURL url = context_->CrackURL(project_url);
 
     base::FilePath target_path = project_path;
     target_path = target_path.Append(file_list[i].name);
 
     context_->operation_runner()->CreateSnapshotFile(
         url,
         base::Bind(&DeveloperPrivateLoadDirectoryFunction::SnapshotFileCallback,
             this,
             target_path));
   }
@@ skipping 10 matching lines @@
                      success_));
     }
   }
 }
 
 void DeveloperPrivateLoadDirectoryFunction::SnapshotFileCallback(
     const base::FilePath& target_path,
     base::File::Error result,
     const base::File::Info& file_info,
     const base::FilePath& src_path,
-    const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
+    const scoped_refptr<storage::ShareableFileReference>& file_ref) {
   if (result != base::File::FILE_OK) {
     SetError("Error in copying files from sync filesystem.");
     success_ = false;
     return;
   }
 
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&DeveloperPrivateLoadDirectoryFunction::CopyFile,
                  this,
                  src_path,
@@ skipping 138 matching lines @@
   }
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions