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

webkit/browser/fileapi/file_system_operation_runner.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/file_system_operation_runner.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/browser/blob/blob_url_request_job_factory.h"
 #include "webkit/browser/fileapi/file_observers.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_writer_delegate.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
-namespace fileapi {
+namespace storage {
 
 typedef FileSystemOperationRunner::OperationID OperationID;
 
 class FileSystemOperationRunner::BeginOperationScoper
     : public base::SupportsWeakPtr<
           FileSystemOperationRunner::BeginOperationScoper> {
  public:
   BeginOperationScoper() {}
  private:
   DISALLOW_COPY_AND_ASSIGN(BeginOperationScoper);
@@ skipping 201 matching lines @@
   operation->Remove(
       url, recursive,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::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) {
   base::File::Error error = base::File::FILE_OK;
   FileSystemOperation* operation =
       file_system_context_->CreateFileSystemOperation(url, &error);
 
   BeginOperationScoper scope;
   OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
   if (!operation) {
     DidWrite(handle, callback, error, 0, true);
     return handle.id;
   }
 
   scoped_ptr<FileStreamWriter> writer(
       file_system_context_->CreateFileStreamWriter(url, offset));
   if (!writer) {
     // Write is not supported.
     DidWrite(handle, callback, base::File::FILE_ERROR_SECURITY, 0, true);
     return handle.id;
   }
 
   FileWriterDelegate::FlushPolicy flush_policy =
       file_system_context_->ShouldFlushOnWriteCompletion(url.type())
           ? FileWriterDelegate::FLUSH_ON_COMPLETION
           : FileWriterDelegate::NO_FLUSH_ON_COMPLETION;
   scoped_ptr<FileWriterDelegate> writer_delegate(
       new FileWriterDelegate(writer.Pass(), flush_policy));
 
   scoped_ptr<net::URLRequest> blob_request(
-      webkit_blob::BlobProtocolHandler::CreateBlobRequest(
-          blob.Pass(),
-          url_request_context,
-          writer_delegate.get()));
+      storage::BlobProtocolHandler::CreateBlobRequest(
+          blob.Pass(), url_request_context, writer_delegate.get()));
 
   PrepareForWrite(handle.id, url);
   operation->Write(
       url, writer_delegate.Pass(), blob_request.Pass(),
       base::Bind(&FileSystemOperationRunner::DidWrite, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::Truncate(
@@ skipping 306 matching lines @@
   callback.Run(file.Pass(), on_close_callback);
   FinishOperation(handle.id);
 }
 
 void FileSystemOperationRunner::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) {
   if (handle.scope) {
     finished_operations_.insert(handle.id);
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(&FileSystemOperationRunner::DidCreateSnapshot,
                               AsWeakPtr(), handle, callback, rv, file_info,
                               platform_path, file_ref));
     return;
   }
   callback.Run(rv, file_info, platform_path, file_ref);
   FinishOperation(handle.id);
@@ skipping 67 matching lines @@
   std::map<OperationID, StatusCallback>::iterator found_cancel =
       stray_cancel_callbacks_.find(id);
   if (found_cancel != stray_cancel_callbacks_.end()) {
     // This cancel has been requested after the operation has finished,
     // so report that we failed to stop it.
     found_cancel->second.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     stray_cancel_callbacks_.erase(found_cancel);
   }
 }
 
-}  // namespace fileapi
+}  // namespace storage