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

storage/browser/fileapi/sandbox_file_system_backend_delegate.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 "webkit/browser/fileapi/sandbox_file_system_backend_delegate.h"
+#include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "net/base/net_util.h"
-#include "webkit/browser/blob/file_stream_reader.h"
-#include "webkit/browser/fileapi/async_file_util_adapter.h"
-#include "webkit/browser/fileapi/file_system_context.h"
-#include "webkit/browser/fileapi/file_system_operation_context.h"
-#include "webkit/browser/fileapi/file_system_url.h"
-#include "webkit/browser/fileapi/file_system_usage_cache.h"
-#include "webkit/browser/fileapi/obfuscated_file_util.h"
-#include "webkit/browser/fileapi/quota/quota_backend_impl.h"
-#include "webkit/browser/fileapi/quota/quota_reservation.h"
-#include "webkit/browser/fileapi/quota/quota_reservation_manager.h"
-#include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
-#include "webkit/browser/fileapi/sandbox_file_system_backend.h"
-#include "webkit/browser/fileapi/sandbox_quota_observer.h"
-#include "webkit/browser/quota/quota_manager_proxy.h"
-#include "webkit/common/fileapi/file_system_util.h"
+#include "storage/browser/blob/file_stream_reader.h"
+#include "storage/browser/fileapi/async_file_util_adapter.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_operation_context.h"
+#include "storage/browser/fileapi/file_system_url.h"
+#include "storage/browser/fileapi/file_system_usage_cache.h"
+#include "storage/browser/fileapi/obfuscated_file_util.h"
+#include "storage/browser/fileapi/quota/quota_backend_impl.h"
+#include "storage/browser/fileapi/quota/quota_reservation.h"
+#include "storage/browser/fileapi/quota/quota_reservation_manager.h"
+#include "storage/browser/fileapi/sandbox_file_stream_writer.h"
+#include "storage/browser/fileapi/sandbox_file_system_backend.h"
+#include "storage/browser/fileapi/sandbox_quota_observer.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
+#include "storage/common/fileapi/file_system_util.h"
 
-namespace fileapi {
+namespace storage {
 
 namespace {
 
 const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
 const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
 
 const char kOpenFileSystemLabel[] = "FileSystem.OpenFileSystem";
 const char kOpenFileSystemDetailLabel[] = "FileSystem.OpenFileSystemDetail";
 const char kOpenFileSystemDetailNonThrottledLabel[] =
     "FileSystem.OpenFileSystemDetailNonthrottled";
 int64 kMinimumStatsCollectionIntervalHours = 1;
 
 // For type directory names in ObfuscatedFileUtil.
 // TODO(kinuko,nhiroki): Each type string registration should be done
 // via its own backend.
 const char kTemporaryDirectoryName[] = "t";
 const char kPersistentDirectoryName[] = "p";
 const char kSyncableDirectoryName[] = "s";
 
-const char* kPrepopulateTypes[] = {
-  kPersistentDirectoryName,
-  kTemporaryDirectoryName
-};
+const char* kPrepopulateTypes[] = {kPersistentDirectoryName,
+                                   kTemporaryDirectoryName};
 
 enum FileSystemError {
   kOK = 0,
   kIncognito,
   kInvalidSchemeError,
   kCreateDirectoryError,
   kNotFound,
   kUnknownError,
   kFileSystemErrorMax,
 };
 
 // Restricted names.
 // http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#naming-restrictions
 const base::FilePath::CharType* const kRestrictedNames[] = {
-  FILE_PATH_LITERAL("."), FILE_PATH_LITERAL(".."),
+    FILE_PATH_LITERAL("."), FILE_PATH_LITERAL(".."),
 };
 
 // Restricted chars.
 const base::FilePath::CharType kRestrictedChars[] = {
-  FILE_PATH_LITERAL('/'), FILE_PATH_LITERAL('\\'),
+    FILE_PATH_LITERAL('/'), FILE_PATH_LITERAL('\\'),
 };
 
 std::string GetTypeStringForURL(const FileSystemURL& url) {
   return SandboxFileSystemBackendDelegate::GetTypeString(url.type());
 }
 
 std::set<std::string> GetKnownTypeStrings() {
   std::set<std::string> known_type_strings;
   known_type_strings.insert(kTemporaryDirectoryName);
   known_type_strings.insert(kPersistentDirectoryName);
   known_type_strings.insert(kSyncableDirectoryName);
   return known_type_strings;
 }
 
 class ObfuscatedOriginEnumerator
     : public SandboxFileSystemBackendDelegate::OriginEnumerator {
  public:
   explicit ObfuscatedOriginEnumerator(ObfuscatedFileUtil* file_util) {
     enum_.reset(file_util->CreateOriginEnumerator());
   }
   virtual ~ObfuscatedOriginEnumerator() {}
 
-  virtual GURL Next() OVERRIDE {
-    return enum_->Next();
-  }
+  virtual GURL Next() OVERRIDE { return enum_->Next(); }
 
   virtual bool HasFileSystemType(FileSystemType type) const OVERRIDE {
     return enum_->HasTypeDirectory(
         SandboxFileSystemBackendDelegate::GetTypeString(type));
   }
 
  private:
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
-void OpenFileSystemOnFileTaskRunner(
-    ObfuscatedFileUtil* file_util,
-    const GURL& origin_url,
-    FileSystemType type,
-    OpenFileSystemMode mode,
-    base::File::Error* error_ptr) {
+void OpenFileSystemOnFileTaskRunner(ObfuscatedFileUtil* file_util,
+                                    const GURL& origin_url,
+                                    FileSystemType type,
+                                    OpenFileSystemMode mode,
+                                    base::File::Error* error_ptr) {
   DCHECK(error_ptr);
   const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
   file_util->GetDirectoryForOriginAndType(
-      origin_url, SandboxFileSystemBackendDelegate::GetTypeString(type),
-      create, error_ptr);
+      origin_url,
+      SandboxFileSystemBackendDelegate::GetTypeString(type),
+      create,
+      error_ptr);
   if (*error_ptr != base::File::FILE_OK) {
-    UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
-                              kCreateDirectoryError,
-                              kFileSystemErrorMax);
+    UMA_HISTOGRAM_ENUMERATION(
+        kOpenFileSystemLabel, kCreateDirectoryError, kFileSystemErrorMax);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel, kOK, kFileSystemErrorMax);
   }
   // The reference of file_util will be derefed on the FILE thread
   // when the storage of this callback gets deleted regardless of whether
   // this method is called or not.
 }
 
 void DidOpenFileSystem(
     base::WeakPtr<SandboxFileSystemBackendDelegate> delegate,
     const base::Callback<void(base::File::Error error)>& callback,
     base::File::Error* error) {
   if (delegate.get())
     delegate.get()->CollectOpenFileSystemMetrics(*error);
   callback.Run(*error);
 }
 
 template <typename T>
 void DeleteSoon(base::SequencedTaskRunner* runner, T* ptr) {
   if (!runner->DeleteSoon(FROM_HERE, ptr))
     delete ptr;
 }
 
 }  // namespace
 
 const base::FilePath::CharType
-SandboxFileSystemBackendDelegate::kFileSystemDirectory[] =
-    FILE_PATH_LITERAL("File System");
+    SandboxFileSystemBackendDelegate::kFileSystemDirectory[] =
+        FILE_PATH_LITERAL("File System");
 
 // static
 std::string SandboxFileSystemBackendDelegate::GetTypeString(
     FileSystemType type) {
   switch (type) {
     case kFileSystemTypeTemporary:
       return kTemporaryDirectoryName;
     case kFileSystemTypePersistent:
       return kPersistentDirectoryName;
     case kFileSystemTypeSyncable:
     case kFileSystemTypeSyncableForInternalSync:
       return kSyncableDirectoryName;
     case kFileSystemTypeUnknown:
     default:
       NOTREACHED() << "Unknown filesystem type requested:" << type;
       return std::string();
   }
 }
 
 SandboxFileSystemBackendDelegate::SandboxFileSystemBackendDelegate(
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::SequencedTaskRunner* file_task_runner,
     const base::FilePath& profile_path,
     quota::SpecialStoragePolicy* special_storage_policy,
     const FileSystemOptions& file_system_options)
     : file_task_runner_(file_task_runner),
       sandbox_file_util_(new AsyncFileUtilAdapter(
-          new ObfuscatedFileUtil(
-              special_storage_policy,
-              profile_path.Append(kFileSystemDirectory),
-              file_system_options.env_override(),
-              file_task_runner,
-              base::Bind(&GetTypeStringForURL),
-              GetKnownTypeStrings(),
-              this))),
+          new ObfuscatedFileUtil(special_storage_policy,
+                                 profile_path.Append(kFileSystemDirectory),
+                                 file_system_options.env_override(),
+                                 file_task_runner,
+                                 base::Bind(&GetTypeStringForURL),
+                                 GetKnownTypeStrings(),
+                                 this))),
       file_system_usage_cache_(new FileSystemUsageCache(file_task_runner)),
-      quota_observer_(new SandboxQuotaObserver(
-          quota_manager_proxy,
-          file_task_runner,
-          obfuscated_file_util(),
-          usage_cache())),
+      quota_observer_(new SandboxQuotaObserver(quota_manager_proxy,
+                                               file_task_runner,
+                                               obfuscated_file_util(),
+                                               usage_cache())),
       quota_reservation_manager_(new QuotaReservationManager(
           scoped_ptr<QuotaReservationManager::QuotaBackend>(
               new QuotaBackendImpl(file_task_runner_,
                                    obfuscated_file_util(),
                                    usage_cache(),
                                    quota_manager_proxy)))),
       special_storage_policy_(special_storage_policy),
       file_system_options_(file_system_options),
       is_filesystem_opened_(false),
       weak_factory_(this) {
   // Prepopulate database only if it can run asynchronously (i.e. the current
   // thread is not file_task_runner). Usually this is the case but may not
   // in test code.
   if (!file_system_options.is_incognito() &&
       !file_task_runner_->RunsTasksOnCurrentThread()) {
     std::vector<std::string> types_to_prepopulate(
         &kPrepopulateTypes[0],
         &kPrepopulateTypes[arraysize(kPrepopulateTypes)]);
     file_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase,
-                  base::Unretained(obfuscated_file_util()),
-                  types_to_prepopulate));
+                   base::Unretained(obfuscated_file_util()),
+                   types_to_prepopulate));
   }
 }
 
 SandboxFileSystemBackendDelegate::~SandboxFileSystemBackendDelegate() {
   io_thread_checker_.DetachFromThread();
 
   if (!file_task_runner_->RunsTasksOnCurrentThread()) {
     DeleteSoon(file_task_runner_.get(), quota_reservation_manager_.release());
     DeleteSoon(file_task_runner_.get(), sandbox_file_util_.release());
     DeleteSoon(file_task_runner_.get(), quota_observer_.release());
@@ skipping 29 matching lines @@
     callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   std::string name = GetFileSystemName(origin_url, type);
 
   base::File::Error* error_ptr = new base::File::Error;
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&OpenFileSystemOnFileTaskRunner,
-                 obfuscated_file_util(), origin_url, type, mode,
+                 obfuscated_file_util(),
+                 origin_url,
+                 type,
+                 mode,
                  base::Unretained(error_ptr)),
       base::Bind(&DidOpenFileSystem,
                  weak_factory_.GetWeakPtr(),
                  base::Bind(callback, root_url, name),
                  base::Owned(error_ptr)));
 
   io_thread_checker_.DetachFromThread();
   is_filesystem_opened_ = true;
 }
 
@@ skipping 13 matching lines @@
 
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
   operation_context->set_update_observers(*update_observers);
   operation_context->set_change_observers(
       change_observers ? *change_observers : ChangeObserverList());
 
   return operation_context.Pass();
 }
 
-scoped_ptr<webkit_blob::FileStreamReader>
+scoped_ptr<storage::FileStreamReader>
 SandboxFileSystemBackendDelegate::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
   if (!IsAccessValid(url))
-    return scoped_ptr<webkit_blob::FileStreamReader>();
-  return scoped_ptr<webkit_blob::FileStreamReader>(
-      webkit_blob::FileStreamReader::CreateForFileSystemFile(
+    return scoped_ptr<storage::FileStreamReader>();
+  return scoped_ptr<storage::FileStreamReader>(
+      storage::FileStreamReader::CreateForFileSystemFile(
           context, url, offset, expected_modification_time));
 }
 
 scoped_ptr<FileStreamWriter>
 SandboxFileSystemBackendDelegate::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context,
     FileSystemType type) const {
   if (!IsAccessValid(url))
     return scoped_ptr<FileStreamWriter>();
   const UpdateObserverList* observers = GetUpdateObservers(type);
   DCHECK(observers);
   return scoped_ptr<FileStreamWriter>(
       new SandboxFileStreamWriter(context, url, offset, *observers));
 }
 
 base::File::Error
 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* file_system_context,
     quota::QuotaManagerProxy* proxy,
     const GURL& origin_url,
     FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
-  int64 usage = GetOriginUsageOnFileTaskRunner(
-      file_system_context, origin_url, type);
+  int64 usage =
+      GetOriginUsageOnFileTaskRunner(file_system_context, origin_url, type);
   usage_cache()->CloseCacheFiles();
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin_url, GetTypeString(type));
   if (result && proxy) {
-    proxy->NotifyStorageModified(
-        quota::QuotaClient::kFileSystem,
-        origin_url,
-        FileSystemTypeToQuotaStorageType(type),
-        -usage);
+    proxy->NotifyStorageModified(quota::QuotaClient::kFileSystem,
+                                 origin_url,
+                                 FileSystemTypeToQuotaStorageType(type),
+                                 -usage);
   }
 
   if (result)
     return base::File::FILE_OK;
   return base::File::FILE_ERROR_FAILED;
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner(
-    FileSystemType type, std::set<GURL>* origins) {
+    FileSystemType type,
+    std::set<GURL>* origins) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
   switch (type) {
     case kFileSystemTypeTemporary:
       UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size());
       break;
     case kFileSystemTypePersistent:
       UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size());
       break;
     default:
       break;
   }
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForHostOnFileTaskRunner(
-    FileSystemType type, const std::string& host,
+    FileSystemType type,
+    const std::string& host,
     std::set<GURL>* origins) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (host == net::GetHostOrSpecFromURL(origin) &&
         enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
@@ skipping 206 matching lines @@
   if (*error_out != base::File::FILE_OK)
     return base::FilePath();
   return base_path.Append(FileSystemUsageCache::kUsageFileName);
 }
 
 int64 SandboxFileSystemBackendDelegate::RecalculateUsage(
     FileSystemContext* context,
     const GURL& origin,
     FileSystemType type) {
   FileSystemOperationContext operation_context(context);
-  FileSystemURL url = context->CreateCrackedFileSystemURL(
-      origin, type, base::FilePath());
+  FileSystemURL url =
+      context->CreateCrackedFileSystemURL(origin, type, base::FilePath());
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
       obfuscated_file_util()->CreateFileEnumerator(
           &operation_context, url, true));
 
   base::FilePath file_path_each;
   int64 usage = 0;
 
   while (!(file_path_each = enumerator->Next()).empty()) {
     usage += enumerator->Size();
     usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
   }
 
   return usage;
 }
 
 void SandboxFileSystemBackendDelegate::CollectOpenFileSystemMetrics(
     base::File::Error error_code) {
   base::Time now = base::Time::Now();
   bool throttled = now < next_release_time_for_open_filesystem_stat_;
   if (!throttled) {
     next_release_time_for_open_filesystem_stat_ =
         now + base::TimeDelta::FromHours(kMinimumStatsCollectionIntervalHours);
   }
 
 #define REPORT(report_value)                                            \
-  UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailLabel,                 \
-                            (report_value),                             \
-                            kFileSystemErrorMax);                       \
+  UMA_HISTOGRAM_ENUMERATION(                                            \
+      kOpenFileSystemDetailLabel, (report_value), kFileSystemErrorMax); \
   if (!throttled) {                                                     \
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailNonThrottledLabel,   \
                               (report_value),                           \
                               kFileSystemErrorMax);                     \
   }
 
   switch (error_code) {
     case base::File::FILE_OK:
       REPORT(kOK);
       break;
@@ skipping 24 matching lines @@
     base::SequencedTaskRunner* file_task_runner) {
   return new ObfuscatedFileUtil(special_storage_policy,
                                 file_system_directory,
                                 env_override,
                                 file_task_runner,
                                 base::Bind(&GetTypeStringForURL),
                                 GetKnownTypeStrings(),
                                 NULL);
 }
 
-}  // namespace fileapi
+}  // namespace storage