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

storage/browser/fileapi/isolated_context.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 "webkit/browser/fileapi/isolated_context.h"
+#include "storage/browser/fileapi/isolated_context.h"
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "webkit/browser/fileapi/file_system_url.h"
+#include "storage/browser/fileapi/file_system_url.h"
 
-namespace fileapi {
+namespace storage {
 
 namespace {
 
 base::FilePath::StringType GetRegisterNameForPath(const base::FilePath& path) {
   // If it's not a root path simply return a base name.
   if (path.DirName() != path)
     return path.BaseName().value();
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   base::FilePath::StringType name;
@@ skipping 17 matching lines @@
   // As of writing dragged file system is the only filesystem which could have
   // multiple top-level paths.
   return type != kFileSystemTypeDragged;
 }
 
 static base::LazyInstance<IsolatedContext>::Leaky g_isolated_context =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-IsolatedContext::FileInfoSet::FileInfoSet() {}
-IsolatedContext::FileInfoSet::~FileInfoSet() {}
+IsolatedContext::FileInfoSet::FileInfoSet() {
+}
+IsolatedContext::FileInfoSet::~FileInfoSet() {
+}
 
-bool IsolatedContext::FileInfoSet::AddPath(
-    const base::FilePath& path, std::string* registered_name) {
+bool IsolatedContext::FileInfoSet::AddPath(const base::FilePath& path,
+                                           std::string* registered_name) {
   // The given path should not contain any '..' and should be absolute.
   if (path.ReferencesParent() || !path.IsAbsolute())
     return false;
   base::FilePath::StringType name = GetRegisterNameForPath(path);
   std::string utf8name = base::FilePath(name).AsUTF8Unsafe();
   base::FilePath normalized_path = path.NormalizePathSeparators();
   bool inserted =
       fileset_.insert(MountPointInfo(utf8name, normalized_path)).second;
   if (!inserted) {
     int suffix = 1;
     std::string basepart =
         base::FilePath(name).RemoveExtension().AsUTF8Unsafe();
     std::string ext =
         base::FilePath(base::FilePath(name).Extension()).AsUTF8Unsafe();
     while (!inserted) {
       utf8name = base::StringPrintf("%s (%d)", basepart.c_str(), suffix++);
       if (!ext.empty())
         utf8name.append(ext);
       inserted =
           fileset_.insert(MountPointInfo(utf8name, normalized_path)).second;
     }
   }
   if (registered_name)
     *registered_name = utf8name;
   return true;
 }
 
-bool IsolatedContext::FileInfoSet::AddPathWithName(
-    const base::FilePath& path, const std::string& name) {
+bool IsolatedContext::FileInfoSet::AddPathWithName(const base::FilePath& path,
+                                                   const std::string& name) {
   // The given path should not contain any '..' and should be absolute.
   if (path.ReferencesParent() || !path.IsAbsolute())
     return false;
-  return fileset_.insert(
-      MountPointInfo(name, path.NormalizePathSeparators())).second;
+  return fileset_.insert(MountPointInfo(name, path.NormalizePathSeparators()))
+      .second;
 }
 
 //--------------------------------------------------------------------------
 
 class IsolatedContext::Instance {
  public:
-  enum PathType {
-    PLATFORM_PATH,
-    VIRTUAL_PATH
-  };
+  enum PathType { PLATFORM_PATH, VIRTUAL_PATH };
 
   // For a single-path isolated file system, which could be registered by
   // IsolatedContext::RegisterFileSystemForPath() or
   // IsolatedContext::RegisterFileSystemForVirtualPath().
   // Most of isolated file system contexts should be of this type.
   Instance(FileSystemType type,
            const std::string& filesystem_id,
            const MountPointInfo& file_info,
            PathType path_type);
 
@@ skipping 43 matching lines @@
     : type_(type),
       filesystem_id_(filesystem_id),
       file_info_(file_info),
       path_type_(path_type),
       ref_counts_(0) {
   DCHECK(IsSinglePathIsolatedFileSystem(type_));
 }
 
 IsolatedContext::Instance::Instance(FileSystemType type,
                                     const std::set<MountPointInfo>& files)
-    : type_(type),
-      path_type_(PLATFORM_PATH),
-      files_(files),
-      ref_counts_(0) {
+    : type_(type), path_type_(PLATFORM_PATH), files_(files), ref_counts_(0) {
   DCHECK(!IsSinglePathIsolatedFileSystem(type_));
 }
 
-IsolatedContext::Instance::~Instance() {}
+IsolatedContext::Instance::~Instance() {
+}
 
 bool IsolatedContext::Instance::ResolvePathForName(const std::string& name,
                                                    base::FilePath* path) const {
   if (IsSinglePathIsolatedFileSystem(type_)) {
     switch (path_type_) {
       case PLATFORM_PATH:
         *path = file_info_.path;
         break;
       case VIRTUAL_PATH:
         *path = base::FilePath();
         break;
       default:
         NOTREACHED();
     }
 
     return file_info_.name == name;
   }
-  std::set<MountPointInfo>::const_iterator found = files_.find(
-      MountPointInfo(name, base::FilePath()));
+  std::set<MountPointInfo>::const_iterator found =
+      files_.find(MountPointInfo(name, base::FilePath()));
   if (found == files_.end())
     return false;
   *path = found->path;
   return true;
 }
 
 bool IsolatedContext::Instance::IsSinglePathInstance() const {
   return IsSinglePathIsolatedFileSystem(type_);
 }
 
 //--------------------------------------------------------------------------
 
 // static
 IsolatedContext* IsolatedContext::GetInstance() {
   return g_isolated_context.Pointer();
 }
 
 // static
 bool IsolatedContext::IsIsolatedType(FileSystemType type) {
   return type == kFileSystemTypeIsolated || type == kFileSystemTypeExternal;
 }
 
 std::string IsolatedContext::RegisterDraggedFileSystem(
     const FileInfoSet& files) {
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
-  instance_map_[filesystem_id] = new Instance(
-      kFileSystemTypeDragged, files.fileset());
+  instance_map_[filesystem_id] =
+      new Instance(kFileSystemTypeDragged, files.fileset());
   return filesystem_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForPath(
     FileSystemType type,
     const std::string& filesystem_id,
     const base::FilePath& path_in,
     std::string* register_name) {
   base::FilePath path(path_in.NormalizePathSeparators());
   if (path.ReferencesParent() || !path.IsAbsolute())
     return std::string();
   std::string name;
   if (register_name && !register_name->empty()) {
     name = *register_name;
   } else {
     name = base::FilePath(GetRegisterNameForPath(path)).AsUTF8Unsafe();
     if (register_name)
       register_name->assign(name);
   }
 
   base::AutoLock locker(lock_);
   std::string new_id = GetNewFileSystemId();
-  instance_map_[new_id] = new Instance(type, filesystem_id,
-                                       MountPointInfo(name, path),
-                                       Instance::PLATFORM_PATH);
+  instance_map_[new_id] = new Instance(
+      type, filesystem_id, MountPointInfo(name, path), Instance::PLATFORM_PATH);
   path_to_id_map_[path].insert(new_id);
   return new_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForVirtualPath(
     FileSystemType type,
     const std::string& register_name,
     const base::FilePath& cracked_path_prefix) {
   base::AutoLock locker(lock_);
   base::FilePath path(cracked_path_prefix.NormalizePathSeparators());
   if (path.ReferencesParent())
     return std::string();
   std::string filesystem_id = GetNewFileSystemId();
-  instance_map_[filesystem_id] = new Instance(
-      type,
-      std::string(),  // filesystem_id
-      MountPointInfo(register_name, cracked_path_prefix),
-      Instance::VIRTUAL_PATH);
+  instance_map_[filesystem_id] =
+      new Instance(type,
+                   std::string(),  // filesystem_id
+                   MountPointInfo(register_name, cracked_path_prefix),
+                   Instance::VIRTUAL_PATH);
   path_to_id_map_[path].insert(filesystem_id);
   return filesystem_id;
 }
 
 bool IsolatedContext::HandlesFileSystemMountType(FileSystemType type) const {
   return type == kFileSystemTypeIsolated;
 }
 
 bool IsolatedContext::RevokeFileSystem(const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
   return UnregisterFileSystem(filesystem_id);
 }
 
-bool IsolatedContext::GetRegisteredPath(
-    const std::string& filesystem_id, base::FilePath* path) const {
+bool IsolatedContext::GetRegisteredPath(const std::string& filesystem_id,
+                                        base::FilePath* path) const {
   DCHECK(path);
   base::AutoLock locker(lock_);
   IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() || !found->second->IsSinglePathInstance())
     return false;
   *path = found->second->file_info().path;
   return true;
 }
 
 bool IsolatedContext::CrackVirtualPath(
@@ skipping 69 matching lines @@
   return CrackFileSystemURL(FileSystemURL(origin, type, path));
 }
 
 void IsolatedContext::RevokeFileSystemByPath(const base::FilePath& path_in) {
   base::AutoLock locker(lock_);
   base::FilePath path(path_in.NormalizePathSeparators());
   PathToID::iterator ids_iter = path_to_id_map_.find(path);
   if (ids_iter == path_to_id_map_.end())
     return;
   std::set<std::string>& ids = ids_iter->second;
-  for (std::set<std::string>::iterator iter = ids.begin();
-       iter != ids.end(); ++iter) {
+  for (std::set<std::string>::iterator iter = ids.begin(); iter != ids.end();
+       ++iter) {
     IDToInstance::iterator found = instance_map_.find(*iter);
     if (found != instance_map_.end()) {
       delete found->second;
       instance_map_.erase(found);
     }
   }
   path_to_id_map_.erase(ids_iter);
 }
 
 void IsolatedContext::AddReference(const std::string& filesystem_id) {
@@ skipping 20 matching lines @@
 
 bool IsolatedContext::GetDraggedFileInfo(
     const std::string& filesystem_id,
     std::vector<MountPointInfo>* files) const {
   DCHECK(files);
   base::AutoLock locker(lock_);
   IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() ||
       found->second->type() != kFileSystemTypeDragged)
     return false;
-  files->assign(found->second->files().begin(),
-                found->second->files().end());
+  files->assign(found->second->files().begin(), found->second->files().end());
   return true;
 }
 
 base::FilePath IsolatedContext::CreateVirtualRootPath(
     const std::string& filesystem_id) const {
   return base::FilePath().AppendASCII(filesystem_id);
 }
 
 IsolatedContext::IsolatedContext() {
 }
 
 IsolatedContext::~IsolatedContext() {
   STLDeleteContainerPairSecondPointers(instance_map_.begin(),
                                        instance_map_.end());
 }
 
 FileSystemURL IsolatedContext::CrackFileSystemURL(
     const FileSystemURL& url) const {
   if (!HandlesFileSystemMountType(url.type()))
     return FileSystemURL();
 
   std::string mount_name;
   std::string cracked_mount_name;
   FileSystemType cracked_type;
   base::FilePath cracked_path;
   FileSystemMountOption cracked_mount_option;
-  if (!CrackVirtualPath(url.path(), &mount_name, &cracked_type,
-                        &cracked_mount_name, &cracked_path,
+  if (!CrackVirtualPath(url.path(),
+                        &mount_name,
+                        &cracked_type,
+                        &cracked_mount_name,
+                        &cracked_path,
                         &cracked_mount_option)) {
     return FileSystemURL();
   }
 
   return FileSystemURL(
-      url.origin(), url.mount_type(), url.virtual_path(),
+      url.origin(),
+      url.mount_type(),
+      url.virtual_path(),
       !url.filesystem_id().empty() ? url.filesystem_id() : mount_name,
-      cracked_type, cracked_path,
+      cracked_type,
+      cracked_path,
       cracked_mount_name.empty() ? mount_name : cracked_mount_name,
       cracked_mount_option);
 }
 
 bool IsolatedContext::UnregisterFileSystem(const std::string& filesystem_id) {
   lock_.AssertAcquired();
   IDToInstance::iterator found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end())
     return false;
   Instance* instance = found->second;
   if (instance->IsSinglePathInstance()) {
-    PathToID::iterator ids_iter = path_to_id_map_.find(
-        instance->file_info().path);
+    PathToID::iterator ids_iter =
+        path_to_id_map_.find(instance->file_info().path);
     DCHECK(ids_iter != path_to_id_map_.end());
     ids_iter->second.erase(filesystem_id);
     if (ids_iter->second.empty())
       path_to_id_map_.erase(ids_iter);
   }
   delete found->second;
   instance_map_.erase(found);
   return true;
 }
 
 std::string IsolatedContext::GetNewFileSystemId() const {
   // Returns an arbitrary random string which must be unique in the map.
   lock_.AssertAcquired();
   uint32 random_data[4];
   std::string id;
   do {
     base::RandBytes(random_data, sizeof(random_data));
     id = base::HexEncode(random_data, sizeof(random_data));
   } while (instance_map_.find(id) != instance_map_.end());
   return id;
 }
 
-}  // namespace fileapi
+}  // namespace storage