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

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_writer.cc

 // Copyright 2014 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 "chrome/browser/chromeos/file_system_provider/fileapi/file_stream_writer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/chromeos/file_system_provider/fileapi/provider_async_file_util.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
@@ skipping 15 matching lines @@
 }  // namespace
 
 class FileStreamWriter::OperationRunner
     : public base::RefCountedThreadSafe<FileStreamWriter::OperationRunner> {
  public:
   OperationRunner() : file_handle_(-1) {}
 
   // Opens a file for writing and calls the completion callback. Must be called
   // on UI thread.
   void OpenFileOnUIThread(
-      const fileapi::FileSystemURL& url,
-      const fileapi::AsyncFileUtil::StatusCallback& callback) {
+      const storage::FileSystemURL& url,
+      const storage::AsyncFileUtil::StatusCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     util::FileSystemURLParser parser(url);
     if (!parser.Parse()) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback, base::File::FILE_ERROR_SECURITY));
       return;
     }
@@ skipping 17 matching lines @@
       abort_callback_ = ProvidedFileSystemInterface::AbortCallback();
     }
   }
 
   // Requests writing bytes to the file. In case of either success or a failure
   // |callback| is executed. Must be called on UI thread.
   void WriteFileOnUIThread(
       scoped_refptr<net::IOBuffer> buffer,
       int64 offset,
       int length,
-      const fileapi::AsyncFileUtil::StatusCallback& callback) {
+      const storage::AsyncFileUtil::StatusCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     // If the file system got unmounted, then abort the writing operation.
     if (!file_system_.get()) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback, base::File::FILE_ERROR_ABORT));
       return;
     }
 
     abort_callback_ = file_system_->WriteFile(
         file_handle_,
         buffer,
         offset,
         length,
         base::Bind(
             &OperationRunner::OnWriteFileCompletedOnUIThread, this, callback));
   }
 
   // Aborts the most recent operation (if exists), and calls the callback.
-  void AbortOnUIThread(const fileapi::AsyncFileUtil::StatusCallback& callback) {
+  void AbortOnUIThread(const storage::AsyncFileUtil::StatusCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (abort_callback_.is_null()) {
       // No operation to be cancelled. At most a callback call, which will be
       // discarded.
       BrowserThread::PostTask(BrowserThread::IO,
                               FROM_HERE,
                               base::Bind(callback, base::File::FILE_OK));
       return;
     }
 
     const ProvidedFileSystemInterface::AbortCallback abort_callback =
         abort_callback_;
     abort_callback_ = ProvidedFileSystemInterface::AbortCallback();
     abort_callback.Run(base::Bind(
         &OperationRunner::OnAbortCompletedOnUIThread, this, callback));
   }
 
  private:
   friend class base::RefCountedThreadSafe<OperationRunner>;
 
   virtual ~OperationRunner() {}
 
   // Remembers a file handle for further operations and forwards the result to
   // the IO thread.
   void OnOpenFileCompletedOnUIThread(
-      const fileapi::AsyncFileUtil::StatusCallback& callback,
+      const storage::AsyncFileUtil::StatusCallback& callback,
       int file_handle,
       base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     file_handle_ = file_handle;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
   }
 
   // Forwards a response of writing to a file to the IO thread.
   void OnWriteFileCompletedOnUIThread(
-      const fileapi::AsyncFileUtil::StatusCallback& callback,
+      const storage::AsyncFileUtil::StatusCallback& callback,
       base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
   }
 
   // Forwards a response of aborting an operation to the IO thread.
   void OnAbortCompletedOnUIThread(
-      const fileapi::AsyncFileUtil::StatusCallback& callback,
+      const storage::AsyncFileUtil::StatusCallback& callback,
       base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(callback, result));
   }
 
   ProvidedFileSystemInterface::AbortCallback abort_callback_;
   base::WeakPtr<ProvidedFileSystemInterface> file_system_;
   int file_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(OperationRunner);
 };
 
-FileStreamWriter::FileStreamWriter(const fileapi::FileSystemURL& url,
+FileStreamWriter::FileStreamWriter(const storage::FileSystemURL& url,
                                    int64 initial_offset)
     : url_(url),
       current_offset_(initial_offset),
       runner_(new OperationRunner),
       state_(NOT_INITIALIZED),
       weak_ptr_factory_(this) {
 }
 
 FileStreamWriter::~FileStreamWriter() {
   BrowserThread::PostTask(
@@ skipping 160 matching lines @@
                  current_offset_,
                  buffer_length,
                  base::Bind(&FileStreamWriter::OnWriteFileCompleted,
                             weak_ptr_factory_.GetWeakPtr(),
                             buffer_length,
                             callback)));
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos