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

chrome/browser/chromeos/file_manager/file_browser_handlers.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/chromeos/file_manager/file_browser_handlers.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 24 matching lines @@
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/fileapi/file_system_info.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
-using fileapi::FileSystemURL;
+using storage::FileSystemURL;
 using file_manager::util::EntryDefinition;
 using file_manager::util::EntryDefinitionList;
 using file_manager::util::FileDefinition;
 using file_manager::util::FileDefinitionList;
 
 namespace file_manager {
 namespace file_browser_handlers {
 namespace {
 
 // Returns process id of the process the extension is running in.
@@ skipping 102 matching lines @@
   void Execute(const std::vector<FileSystemURL>& file_urls,
                const file_tasks::FileTaskFinishedCallback& done);
 
  private:
   // This object is responsible to delete itself.
   virtual ~FileBrowserHandlerExecutor();
 
   // Checks legitimacy of file url and grants file RO access permissions from
   // handler (target) extension and its renderer process.
   static scoped_ptr<FileDefinitionList> SetupFileAccessPermissions(
-      scoped_refptr<fileapi::FileSystemContext> file_system_context_handler,
+      scoped_refptr<storage::FileSystemContext> file_system_context_handler,
       const scoped_refptr<const Extension>& handler_extension,
       const std::vector<FileSystemURL>& file_urls);
 
   void ExecuteDoneOnUIThread(bool success);
   void ExecuteAfterSetupFileAccess(scoped_ptr<FileDefinitionList> file_list);
   void ExecuteFileActionsOnUIThread(
       scoped_ptr<FileDefinitionList> file_definition_list,
       scoped_ptr<EntryDefinitionList> entry_definition_list);
   void SetupPermissionsAndDispatchEvent(
       scoped_ptr<FileDefinitionList> file_definition_list,
@@ skipping 13 matching lines @@
   const std::string action_id_;
   file_tasks::FileTaskFinishedCallback done_;
   base::WeakPtrFactory<FileBrowserHandlerExecutor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileBrowserHandlerExecutor);
 };
 
 // static
 scoped_ptr<FileDefinitionList>
 FileBrowserHandlerExecutor::SetupFileAccessPermissions(
-    scoped_refptr<fileapi::FileSystemContext> file_system_context_handler,
+    scoped_refptr<storage::FileSystemContext> file_system_context_handler,
     const scoped_refptr<const Extension>& handler_extension,
     const std::vector<FileSystemURL>& file_urls) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(handler_extension.get());
 
-  fileapi::ExternalFileSystemBackend* backend =
+  storage::ExternalFileSystemBackend* backend =
       file_system_context_handler->external_backend();
 
   scoped_ptr<FileDefinitionList> file_definition_list(new FileDefinitionList);
   for (size_t i = 0; i < file_urls.size(); ++i) {
     const FileSystemURL& url = file_urls[i];
 
     // Check if this file system entry exists first.
     base::File::Info file_info;
 
     base::FilePath local_path = url.path();
     base::FilePath virtual_path = url.virtual_path();
 
-    const bool is_drive_file = url.type() == fileapi::kFileSystemTypeDrive;
+    const bool is_drive_file = url.type() == storage::kFileSystemTypeDrive;
     DCHECK(!is_drive_file || drive::util::IsUnderDriveMountPoint(local_path));
 
     const bool is_native_file =
-        url.type() == fileapi::kFileSystemTypeNativeLocal ||
-        url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal;
+        url.type() == storage::kFileSystemTypeNativeLocal ||
+        url.type() == storage::kFileSystemTypeRestrictedNativeLocal;
 
     // If the file is from a physical volume, actual file must be found.
     if (is_native_file) {
       if (!base::PathExists(local_path) ||
           base::IsLink(local_path) ||
           !base::GetFileInfo(local_path, &file_info)) {
         continue;
       }
     }
 
@@ skipping 26 matching lines @@
 FileBrowserHandlerExecutor::~FileBrowserHandlerExecutor() {}
 
 void FileBrowserHandlerExecutor::Execute(
     const std::vector<FileSystemURL>& file_urls,
     const file_tasks::FileTaskFinishedCallback& done) {
   done_ = done;
 
   // Get file system context for the extension to which onExecute event will be
   // sent. The file access permissions will be granted to the extension in the
   // file system context for the files in |file_urls|.
-  scoped_refptr<fileapi::FileSystemContext> file_system_context(
-      util::GetFileSystemContextForExtensionId(
-          profile_, extension_->id()));
+  scoped_refptr<storage::FileSystemContext> file_system_context(
+      util::GetFileSystemContextForExtensionId(profile_, extension_->id()));
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&SetupFileAccessPermissions,
                  file_system_context,
                  extension_,
                  file_urls),
       base::Bind(&FileBrowserHandlerExecutor::ExecuteAfterSetupFileAccess,
                  weak_ptr_factory_.GetWeakPtr()));
@@ skipping 231 matching lines @@
       if (common_handlers.empty())
         return FileBrowserHandlerList();
     }
   }
 
   return common_handlers;
 }
 
 }  // namespace file_browser_handlers
 }  // namespace file_manager