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

storage/browser/fileapi/file_system_operation_runner.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_FILE_SYSTEM_OPERATION_RUNNER_H_
 #define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_RUNNER_H_
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/id_map.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "webkit/browser/blob/blob_data_handle.h"
-#include "webkit/browser/fileapi/file_system_operation.h"
-#include "webkit/browser/fileapi/file_system_url.h"
-#include "webkit/browser/webkit_storage_browser_export.h"
+#include "storage/browser/blob/blob_data_handle.h"
+#include "storage/browser/fileapi/file_system_operation.h"
+#include "storage/browser/fileapi/file_system_url.h"
+#include "storage/common/storage_export.h"
 
 namespace net {
 class URLRequestContext;
 }
 
-namespace fileapi {
+namespace storage {
 
 class FileSystemURL;
 class FileSystemContext;
 
 // A central interface for running FileSystem API operations.
 // All operation methods take callback and returns OperationID, which is
 // an integer value which can be used for cancelling an operation.
 // All operation methods return kErrorOperationID if running (posting) an
 // operation fails, in addition to dispatching the callback with an error
 // code (therefore in most cases the caller does not need to check the
 // returned operation ID).
-class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemOperationRunner
+class STORAGE_EXPORT FileSystemOperationRunner
     : public base::SupportsWeakPtr<FileSystemOperationRunner> {
  public:
   typedef FileSystemOperation::GetMetadataCallback GetMetadataCallback;
   typedef FileSystemOperation::ReadDirectoryCallback ReadDirectoryCallback;
   typedef FileSystemOperation::SnapshotFileCallback SnapshotFileCallback;
   typedef FileSystemOperation::StatusCallback StatusCallback;
   typedef FileSystemOperation::WriteCallback WriteCallback;
   typedef FileSystemOperation::OpenFileCallback OpenFileCallback;
   typedef FileSystemOperation::CopyProgressCallback CopyProgressCallback;
   typedef FileSystemOperation::CopyFileProgressCallback
@@ skipping 49 matching lines @@
   // Gets the metadata of a file or directory at |url|.
   OperationID GetMetadata(const FileSystemURL& url,
                           const GetMetadataCallback& callback);
 
   // Reads contents of a directory at |url|.
   OperationID ReadDirectory(const FileSystemURL& url,
                             const ReadDirectoryCallback& callback);
 
   // Removes a file or directory at |url|. If |recursive| is true, remove
   // all files and directories under the directory at |url| recursively.
-  OperationID Remove(const FileSystemURL& url, bool recursive,
+  OperationID Remove(const FileSystemURL& url,
+                     bool recursive,
                      const StatusCallback& callback);
 
   // Writes contents of |blob_url| to |url| at |offset|.
   // |url_request_context| is used to read contents in |blob|.
   OperationID Write(const net::URLRequestContext* url_request_context,
                     const FileSystemURL& url,
-                    scoped_ptr<webkit_blob::BlobDataHandle> blob,
+                    scoped_ptr<storage::BlobDataHandle> blob,
                     int64 offset,
                     const WriteCallback& callback);
 
   // Truncates a file at |url| to |length|. If |length| is larger than
   // the original file size, the file will be extended, and the extended
   // part is filled with null bytes.
-  OperationID Truncate(const FileSystemURL& url, int64 length,
+  OperationID Truncate(const FileSystemURL& url,
+                       int64 length,
                        const StatusCallback& callback);
 
   // Tries to cancel the operation |id| [we support cancelling write or
   // truncate only]. Reports failure for the current operation, then reports
   // success for the cancel operation itself via the |callback|.
   void Cancel(OperationID id, const StatusCallback& callback);
 
   // Modifies timestamps of a file or directory at |url| with
   // |last_access_time| and |last_modified_time|. The function DOES NOT
   // create a file unlike 'touch' command on Linux.
@@ skipping 129 matching lines @@
   void DidReadDirectory(const OperationHandle& handle,
                         const ReadDirectoryCallback& callback,
                         base::File::Error rv,
                         const std::vector<DirectoryEntry>& entries,
                         bool has_more);
   void DidWrite(const OperationHandle& handle,
                 const WriteCallback& callback,
                 base::File::Error rv,
                 int64 bytes,
                 bool complete);
-  void DidOpenFile(
-      const OperationHandle& handle,
-      const OpenFileCallback& callback,
-      base::File file,
-      const base::Closure& on_close_callback);
+  void DidOpenFile(const OperationHandle& handle,
+                   const OpenFileCallback& callback,
+                   base::File file,
+                   const base::Closure& on_close_callback);
   void DidCreateSnapshot(
       const OperationHandle& handle,
       const SnapshotFileCallback& callback,
       base::File::Error rv,
       const base::File::Info& file_info,
       const base::FilePath& platform_path,
-      const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref);
+      const scoped_refptr<storage::ShareableFileReference>& file_ref);
 
-  void OnCopyProgress(
-      const OperationHandle& handle,
-      const CopyProgressCallback& callback,
-      FileSystemOperation::CopyProgressType type,
-      const FileSystemURL& source_url,
-      const FileSystemURL& dest_url,
-      int64 size);
+  void OnCopyProgress(const OperationHandle& handle,
+                      const CopyProgressCallback& callback,
+                      FileSystemOperation::CopyProgressType type,
+                      const FileSystemURL& source_url,
+                      const FileSystemURL& dest_url,
+                      int64 size);
 
   void PrepareForWrite(OperationID id, const FileSystemURL& url);
   void PrepareForRead(OperationID id, const FileSystemURL& url);
 
   // These must be called at the beginning and end of any async operations.
   OperationHandle BeginOperation(FileSystemOperation* operation,
                                  base::WeakPtr<BeginOperationScoper> scope);
   void FinishOperation(OperationID id);
 
   // Not owned; file_system_context owns this.
   FileSystemContext* file_system_context_;
 
   // IDMap<FileSystemOperation, IDMapOwnPointer> operations_;
   IDMap<FileSystemOperation, IDMapOwnPointer> operations_;
 
   // We keep track of the file to be modified by each operation so that
   // we can notify observers when we're done.
   typedef std::map<OperationID, FileSystemURLSet> OperationToURLSet;
   OperationToURLSet write_target_urls_;
 
   // Operations that are finished but not yet fire their callbacks.
   std::set<OperationID> finished_operations_;
 
   // Callbacks for stray cancels whose target operation is already finished.
   std::map<OperationID, StatusCallback> stray_cancel_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationRunner);
 };
 
-}  // namespace fileapi
+}  // namespace storage
 
 #endif  // WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_OPERATION_RUNNER_H_