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

chrome/browser/devtools/devtools_file_helper.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/devtools/devtools_file_helper.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 113 matching lines @@
   base::WriteFile(path, content.c_str(), content.length());
 }
 
 void AppendToFile(const base::FilePath& path, const std::string& content) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(!path.empty());
 
   base::AppendToFile(path, content.c_str(), content.length());
 }
 
-fileapi::IsolatedContext* isolated_context() {
+storage::IsolatedContext* isolated_context() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  fileapi::IsolatedContext* isolated_context =
-      fileapi::IsolatedContext::GetInstance();
+  storage::IsolatedContext* isolated_context =
+      storage::IsolatedContext::GetInstance();
   DCHECK(isolated_context);
   return isolated_context;
 }
 
 std::string RegisterFileSystem(WebContents* web_contents,
                                const base::FilePath& path,
                                std::string* registered_name) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(web_contents->GetURL().SchemeIs(content::kChromeDevToolsScheme));
   std::string file_system_id = isolated_context()->RegisterFileSystemForPath(
-      fileapi::kFileSystemTypeNativeLocal, std::string(), path,
+      storage::kFileSystemTypeNativeLocal,
+      std::string(),
+      path,
       registered_name);
 
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
   int renderer_id = render_view_host->GetProcess()->GetID();
   policy->GrantReadFileSystem(renderer_id, file_system_id);
   policy->GrantWriteFileSystem(renderer_id, file_system_id);
   policy->GrantCreateFileForFileSystem(renderer_id, file_system_id);
   policy->GrantDeleteFromFileSystem(renderer_id, file_system_id);
 
   // We only need file level access for reading FileEntries. Saving FileEntries
   // just needs the file system to have read/write access, which is granted
   // above if required.
   if (!policy->CanReadFile(renderer_id, path))
     policy->GrantReadFile(renderer_id, path);
 
   return file_system_id;
 }
 
 DevToolsFileHelper::FileSystem CreateFileSystemStruct(
     WebContents* web_contents,
     const std::string& file_system_id,
     const std::string& registered_name,
     const std::string& file_system_path) {
   const GURL origin = web_contents->GetURL().GetOrigin();
-  std::string file_system_name = fileapi::GetIsolatedFileSystemName(
-      origin,
-      file_system_id);
-  std::string root_url = fileapi::GetIsolatedFileSystemRootURIString(
-      origin,
-      file_system_id,
-      registered_name);
+  std::string file_system_name =
+      storage::GetIsolatedFileSystemName(origin, file_system_id);
+  std::string root_url = storage::GetIsolatedFileSystemRootURIString(
+      origin, file_system_id, registered_name);
   return DevToolsFileHelper::FileSystem(file_system_name,
                                         root_url,
                                         file_system_path);
 }
 
 set<std::string> GetAddedFileSystemPaths(Profile* profile) {
   const base::DictionaryValue* file_systems_paths_value =
       profile->GetPrefs()->GetDictionary(prefs::kDevToolsFileSystemPaths);
   set<std::string> result;
   for (base::DictionaryValue::Iterator it(*file_systems_paths_value);
@@ skipping 121 matching lines @@
       Bind(callback, FileSystem()),
       web_contents_);
   select_file_dialog->Show(ui::SelectFileDialog::SELECT_FOLDER,
                            base::FilePath());
 }
 
 void DevToolsFileHelper::UpgradeDraggedFileSystemPermissions(
     const std::string& file_system_url,
     const AddFileSystemCallback& callback,
     const ShowInfoBarCallback& show_info_bar_callback) {
-  fileapi::FileSystemURL root_url =
+  storage::FileSystemURL root_url =
       isolated_context()->CrackURL(GURL(file_system_url));
   if (!root_url.is_valid() || !root_url.path().empty()) {
     callback.Run(FileSystem());
     return;
   }
 
-  std::vector<fileapi::MountPoints::MountPointInfo> mount_points;
+  std::vector<storage::MountPoints::MountPointInfo> mount_points;
   isolated_context()->GetDraggedFileInfo(root_url.filesystem_id(),
                                          &mount_points);
 
-  std::vector<fileapi::MountPoints::MountPointInfo>::const_iterator it =
+  std::vector<storage::MountPoints::MountPointInfo>::const_iterator it =
       mount_points.begin();
   for (; it != mount_points.end(); ++it)
     InnerAddFileSystem(callback, show_info_bar_callback, it->path);
 }
 
 void DevToolsFileHelper::InnerAddFileSystem(
     const AddFileSystemCallback& callback,
     const ShowInfoBarCallback& show_info_bar_callback,
     const base::FilePath& path) {
   std::string file_system_path = path.AsUTF8Unsafe();
@@ skipping 75 matching lines @@
   base::DictionaryValue* file_systems_paths_value = update.Get();
   file_systems_paths_value->RemoveWithoutPathExpansion(file_system_path, NULL);
 }
 
 bool DevToolsFileHelper::IsFileSystemAdded(
     const std::string& file_system_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   set<std::string> file_system_paths = GetAddedFileSystemPaths(profile_);
   return file_system_paths.find(file_system_path) != file_system_paths.end();
 }