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

webkit/browser/fileapi/copy_or_move_operation_delegate.cc

 // Copyright (c) 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/copy_or_move_operation_delegate.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/recursive_operation_delegate.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-namespace fileapi {
+namespace storage {
 
 const int64 kFlushIntervalInBytes = 10 << 20;  // 10MB.
 
 class CopyOrMoveOperationDelegate::CopyOrMoveImpl {
  public:
   virtual ~CopyOrMoveImpl() {}
   virtual void Run(
       const CopyOrMoveOperationDelegate::StatusCallback& callback) = 0;
   virtual void Cancel() = 0;
 
@@ skipping 92 matching lines @@
   virtual void Cancel() OVERRIDE {
     cancel_requested_ = true;
   }
 
  private:
   void RunAfterCreateSnapshot(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       base::File::Error error,
       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) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     // For now we assume CreateSnapshotFile always return a valid local file
     // path.
@@ skipping 10 matching lines @@
     PreWriteValidation(
         platform_path,
         base::Bind(&SnapshotCopyOrMoveImpl::RunAfterPreWriteValidation,
                    weak_factory_.GetWeakPtr(),
                    platform_path, file_info, file_ref, callback));
   }
 
   void RunAfterPreWriteValidation(
       const base::FilePath& platform_path,
       const base::File::Info& file_info,
-      const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref,
+      const scoped_refptr<storage::ShareableFileReference>& file_ref,
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       base::File::Error error) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     // |file_ref| is unused but necessary to keep the file alive until
     // CopyInForeignFile() is completed.
     operation_runner_->CopyInForeignFile(
         platform_path, dest_url_,
         base::Bind(&SnapshotCopyOrMoveImpl::RunAfterCopyInForeignFile,
                    weak_factory_.GetWeakPtr(), file_info, file_ref, callback));
   }
 
   void RunAfterCopyInForeignFile(
       const base::File::Info& file_info,
-      const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref,
+      const scoped_refptr<storage::ShareableFileReference>& file_ref,
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       base::File::Error error) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
@@ skipping 106 matching lines @@
         base::Bind(
             &SnapshotCopyOrMoveImpl::PostWriteValidationAfterCreateSnapshotFile,
             weak_factory_.GetWeakPtr(), callback));
   }
 
   void PostWriteValidationAfterCreateSnapshotFile(
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       base::File::Error error,
       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) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     DCHECK(validator_);
     // Note: file_ref passed here to keep the file alive until after
     // the StartPostWriteValidation operation finishes.
     validator_->StartPostWriteValidation(
         platform_path,
         base::Bind(&SnapshotCopyOrMoveImpl::DidPostWriteValidation,
                    weak_factory_.GetWeakPtr(), file_ref, callback));
   }
 
   // |file_ref| is unused; it is passed here to make sure the reference is
   // alive until after post-write validation is complete.
   void DidPostWriteValidation(
-      const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref,
+      const scoped_refptr<storage::ShareableFileReference>& file_ref,
       const CopyOrMoveOperationDelegate::StatusCallback& callback,
       base::File::Error error) {
     callback.Run(error);
   }
 
   FileSystemOperationRunner* operation_runner_;
   CopyOrMoveOperationDelegate::OperationType operation_type_;
   FileSystemURL src_url_;
   FileSystemURL dest_url_;
 
@@ skipping 18 matching lines @@
 // necessary SnapshotCopyOrMoveImpl should be used.
 class StreamCopyOrMoveImpl
     : public CopyOrMoveOperationDelegate::CopyOrMoveImpl {
  public:
   StreamCopyOrMoveImpl(
       FileSystemOperationRunner* operation_runner,
       CopyOrMoveOperationDelegate::OperationType operation_type,
       const FileSystemURL& src_url,
       const FileSystemURL& dest_url,
       CopyOrMoveOperationDelegate::CopyOrMoveOption option,
-      scoped_ptr<webkit_blob::FileStreamReader> reader,
+      scoped_ptr<storage::FileStreamReader> reader,
       scoped_ptr<FileStreamWriter> writer,
       const FileSystemOperation::CopyFileProgressCallback&
           file_progress_callback)
       : operation_runner_(operation_runner),
         operation_type_(operation_type),
         src_url_(src_url),
         dest_url_(dest_url),
         option_(option),
         reader_(reader.Pass()),
         writer_(writer.Pass()),
         file_progress_callback_(file_progress_callback),
         cancel_requested_(false),
-        weak_factory_(this) {
-  }
+        weak_factory_(this) {}
 
   virtual void Run(
       const CopyOrMoveOperationDelegate::StatusCallback& callback) OVERRIDE {
     // Reader can be created even if the entry does not exist or the entry is
     // a directory. To check errors before destination file creation,
     // check metadata first.
     operation_runner_->GetMetadata(
         src_url_,
         base::Bind(&StreamCopyOrMoveImpl::RunAfterGetMetadataForSource,
                    weak_factory_.GetWeakPtr(), callback));
@@ skipping 38 matching lines @@
       base::File::Error error) {
     if (cancel_requested_)
       error = base::File::FILE_ERROR_ABORT;
 
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     const bool need_flush = dest_url_.mount_option().copy_sync_option() ==
-        fileapi::COPY_SYNC_OPTION_SYNC;
+                            storage::COPY_SYNC_OPTION_SYNC;
 
     DCHECK(!copy_helper_);
     copy_helper_.reset(
         new CopyOrMoveOperationDelegate::StreamCopyHelper(
             reader_.Pass(), writer_.Pass(),
             need_flush,
             kReadBufferSize,
             file_progress_callback_,
             base::TimeDelta::FromMilliseconds(
                 kMinProgressCallbackInvocationSpanInMilliseconds)));
@@ skipping 56 matching lines @@
     if (error == base::File::FILE_ERROR_NOT_FOUND)
       error = base::File::FILE_OK;
     callback.Run(error);
   }
 
   FileSystemOperationRunner* operation_runner_;
   CopyOrMoveOperationDelegate::OperationType operation_type_;
   FileSystemURL src_url_;
   FileSystemURL dest_url_;
   CopyOrMoveOperationDelegate::CopyOrMoveOption option_;
-  scoped_ptr<webkit_blob::FileStreamReader> reader_;
+  scoped_ptr<storage::FileStreamReader> reader_;
   scoped_ptr<FileStreamWriter> writer_;
   FileSystemOperation::CopyFileProgressCallback file_progress_callback_;
   scoped_ptr<CopyOrMoveOperationDelegate::StreamCopyHelper> copy_helper_;
   bool cancel_requested_;
   base::WeakPtrFactory<StreamCopyOrMoveImpl> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(StreamCopyOrMoveImpl);
 };
 
 }  // namespace
 
 CopyOrMoveOperationDelegate::StreamCopyHelper::StreamCopyHelper(
-    scoped_ptr<webkit_blob::FileStreamReader> reader,
+    scoped_ptr<storage::FileStreamReader> reader,
     scoped_ptr<FileStreamWriter> writer,
     bool need_flush,
     int buffer_size,
-    const FileSystemOperation::CopyFileProgressCallback&
-        file_progress_callback,
+    const FileSystemOperation::CopyFileProgressCallback& file_progress_callback,
     const base::TimeDelta& min_progress_callback_invocation_span)
     : reader_(reader.Pass()),
       writer_(writer.Pass()),
       need_flush_(need_flush),
       file_progress_callback_(file_progress_callback),
       io_buffer_(new net::IOBufferWithSize(buffer_size)),
       num_copied_bytes_(0),
       previous_flush_offset_(0),
       min_progress_callback_invocation_span_(
           min_progress_callback_invocation_span),
@@ skipping 199 matching lines @@
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     CopyOrMoveFileValidatorFactory* validator_factory =
         file_system_context()->GetCopyOrMoveFileValidatorFactory(
             dest_root_.type(), &error);
     if (error != base::File::FILE_OK) {
       callback.Run(error);
       return;
     }
 
     if (!validator_factory) {
-      scoped_ptr<webkit_blob::FileStreamReader> reader =
+      scoped_ptr<storage::FileStreamReader> reader =
           file_system_context()->CreateFileStreamReader(
               src_url, 0, base::Time());
       scoped_ptr<FileStreamWriter> writer =
           file_system_context()->CreateFileStreamWriter(dest_url, 0);
       if (reader && writer) {
         impl = new StreamCopyOrMoveImpl(
             operation_runner(), operation_type_, src_url, dest_url, option_,
             reader.Pass(), writer.Pass(),
             base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress,
                        weak_factory_.GetWeakPtr(), src_url));
@@ skipping 187 matching lines @@
 
   base::FilePath relative = dest_root_.virtual_path();
   src_root_.virtual_path().AppendRelativePath(src_url.virtual_path(),
                                               &relative);
   return file_system_context()->CreateCrackedFileSystemURL(
       dest_root_.origin(),
       dest_root_.mount_type(),
       relative);
 }
 
-}  // namespace fileapi
+}  // namespace storage