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

storage/browser/fileapi/sandbox_file_system_backend_delegate.h

 // 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.
 
 #ifndef WEBKIT_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_
 #define WEBKIT_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
-#include "webkit/browser/fileapi/file_system_backend.h"
-#include "webkit/browser/fileapi/file_system_options.h"
-#include "webkit/browser/fileapi/file_system_quota_util.h"
-#include "webkit/browser/webkit_storage_browser_export.h"
+#include "storage/browser/fileapi/file_system_backend.h"
+#include "storage/browser/fileapi/file_system_options.h"
+#include "storage/browser/fileapi/file_system_quota_util.h"
+#include "storage/common/storage_export.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace content {
 class SandboxFileSystemBackendDelegateTest;
 class SandboxFileSystemTestHelper;
 }
 
 namespace quota {
 class QuotaManagerProxy;
 class SpecialStoragePolicy;
 }
 
-namespace webkit_blob {
+namespace storage {
 class FileStreamReader;
 }
 
-namespace fileapi {
+namespace storage {
 
 class AsyncFileUtil;
 class FileStreamWriter;
 class FileSystemFileUtil;
 class FileSystemOperationContext;
 class FileSystemURL;
 class FileSystemUsageCache;
 class ObfuscatedFileUtil;
 class QuotaReservationManager;
 class SandboxFileSystemBackend;
 class SandboxQuotaObserver;
 
 // Delegate implementation of the some methods in Sandbox/SyncFileSystemBackend.
 // An instance of this class is created and owned by FileSystemContext.
-class WEBKIT_STORAGE_BROWSER_EXPORT SandboxFileSystemBackendDelegate
+class STORAGE_EXPORT SandboxFileSystemBackendDelegate
     : public FileSystemQuotaUtil {
  public:
   typedef FileSystemBackend::OpenFileSystemCallback OpenFileSystemCallback;
 
   // The FileSystem directory name.
   static const base::FilePath::CharType kFileSystemDirectory[];
 
   // Origin enumerator interface.
   // An instance of this interface is assumed to be called on the file thread.
   class OriginEnumerator {
@@ skipping 22 matching lines @@
   // Returns an origin enumerator of sandbox filesystem.
   // This method can only be called on the file thread.
   OriginEnumerator* CreateOriginEnumerator();
 
   // Gets a base directory path of the sandboxed filesystem that is
   // specified by |origin_url| and |type|.
   // (The path is similar to the origin's root path but doesn't contain
   // the 'unique' part.)
   // Returns an empty path if the given type is invalid.
   // This method can only be called on the file thread.
-  base::FilePath GetBaseDirectoryForOriginAndType(
-      const GURL& origin_url,
-      FileSystemType type,
-      bool create);
+  base::FilePath GetBaseDirectoryForOriginAndType(const GURL& origin_url,
+                                                  FileSystemType type,
+                                                  bool create);
 
   // FileSystemBackend helpers.
-  void OpenFileSystem(
-      const GURL& origin_url,
-      FileSystemType type,
-      OpenFileSystemMode mode,
-      const OpenFileSystemCallback& callback,
-      const GURL& root_url);
+  void OpenFileSystem(const GURL& origin_url,
+                      FileSystemType type,
+                      OpenFileSystemMode mode,
+                      const OpenFileSystemCallback& callback,
+                      const GURL& root_url);
   scoped_ptr<FileSystemOperationContext> CreateFileSystemOperationContext(
       const FileSystemURL& url,
       FileSystemContext* context,
       base::File::Error* error_code) const;
-  scoped_ptr<webkit_blob::FileStreamReader> CreateFileStreamReader(
+  scoped_ptr<storage::FileStreamReader> CreateFileStreamReader(
       const FileSystemURL& url,
       int64 offset,
       const base::Time& expected_modification_time,
       FileSystemContext* context) const;
   scoped_ptr<FileStreamWriter> CreateFileStreamWriter(
       const FileSystemURL& url,
       int64 offset,
       FileSystemContext* context,
       FileSystemType type) const;
 
   // FileSystemQuotaUtil overrides.
   virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
       FileSystemContext* context,
       quota::QuotaManagerProxy* proxy,
       const GURL& origin_url,
       FileSystemType type) OVERRIDE;
   virtual void GetOriginsForTypeOnFileTaskRunner(
       FileSystemType type,
       std::set<GURL>* origins) OVERRIDE;
   virtual void GetOriginsForHostOnFileTaskRunner(
       FileSystemType type,
       const std::string& host,
       std::set<GURL>* origins) OVERRIDE;
-  virtual int64 GetOriginUsageOnFileTaskRunner(
-      FileSystemContext* context,
-      const GURL& origin_url,
-      FileSystemType type) OVERRIDE;
+  virtual int64 GetOriginUsageOnFileTaskRunner(FileSystemContext* context,
+                                               const GURL& origin_url,
+                                               FileSystemType type) OVERRIDE;
   virtual scoped_refptr<QuotaReservation>
-      CreateQuotaReservationOnFileTaskRunner(
-          const GURL& origin_url,
-          FileSystemType type) OVERRIDE;
+      CreateQuotaReservationOnFileTaskRunner(const GURL& origin_url,
+                                             FileSystemType type) OVERRIDE;
   virtual void AddFileUpdateObserver(
       FileSystemType type,
       FileUpdateObserver* observer,
       base::SequencedTaskRunner* task_runner) OVERRIDE;
   virtual void AddFileChangeObserver(
       FileSystemType type,
       FileChangeObserver* observer,
       base::SequencedTaskRunner* task_runner) OVERRIDE;
   virtual void AddFileAccessObserver(
       FileSystemType type,
       FileAccessObserver* observer,
       base::SequencedTaskRunner* task_runner) OVERRIDE;
   virtual const UpdateObserverList* GetUpdateObservers(
       FileSystemType type) const OVERRIDE;
   virtual const ChangeObserverList* GetChangeObservers(
       FileSystemType type) const OVERRIDE;
   virtual const AccessObserverList* GetAccessObservers(
       FileSystemType type) const OVERRIDE;
 
   // Registers quota observer for file updates on filesystem of |type|.
   void RegisterQuotaUpdateObserver(FileSystemType type);
 
-  void InvalidateUsageCache(const GURL& origin_url,
-                            FileSystemType type);
-  void StickyInvalidateUsageCache(const GURL& origin_url,
-                                  FileSystemType type);
+  void InvalidateUsageCache(const GURL& origin_url, FileSystemType type);
+  void StickyInvalidateUsageCache(const GURL& origin_url, FileSystemType type);
 
   void CollectOpenFileSystemMetrics(base::File::Error error_code);
 
   base::SequencedTaskRunner* file_task_runner() {
     return file_task_runner_.get();
   }
 
   AsyncFileUtil* file_util() { return sandbox_file_util_.get(); }
   FileSystemUsageCache* usage_cache() { return file_system_usage_cache_.get(); }
   SandboxQuotaObserver* quota_observer() { return quota_observer_.get(); }
@@ skipping 16 matching lines @@
 
   // Performs API-specific validity checks on the given path |url|.
   // Returns true if access to |url| is valid in this filesystem.
   bool IsAccessValid(const FileSystemURL& url) const;
 
   // Returns true if the given |url|'s scheme is allowed to access
   // filesystem.
   bool IsAllowedScheme(const GURL& url) const;
 
   // Returns a path to the usage cache file.
-  base::FilePath GetUsageCachePathForOriginAndType(
-      const GURL& origin_url,
-      FileSystemType type);
+  base::FilePath GetUsageCachePathForOriginAndType(const GURL& origin_url,
+                                                   FileSystemType type);
 
   // Returns a path to the usage cache file (static version).
   static base::FilePath GetUsageCachePathForOriginAndType(
       ObfuscatedFileUtil* sandbox_file_util,
       const GURL& origin_url,
       FileSystemType type,
       base::File::Error* error_out);
 
   int64 RecalculateUsage(FileSystemContext* context,
                          const GURL& origin,
@@ skipping 24 matching lines @@
   std::map<FileSystemType, ChangeObserverList> change_observers_;
   std::map<FileSystemType, AccessObserverList> access_observers_;
 
   base::Time next_release_time_for_open_filesystem_stat_;
 
   base::WeakPtrFactory<SandboxFileSystemBackendDelegate> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SandboxFileSystemBackendDelegate);
 };
 
-}  // namespace fileapi
+}  // namespace storage
 
 #endif  // WEBKIT_BROWSER_FILEAPI_SANDBOX_FILE_SYSTEM_BACKEND_DELEGATE_H_