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

storage/browser/fileapi/local_file_stream_writer.cc

 // Copyright (c) 2012 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/local_file_stream_writer.h"
+#include "storage/browser/fileapi/local_file_stream_writer.h"
 
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
-namespace fileapi {
+namespace storage {
 
 namespace {
 
-const int kOpenFlagsForWrite = base::File::FLAG_OPEN |
-                               base::File::FLAG_WRITE |
-                               base::File::FLAG_ASYNC;
-const int kCreateFlagsForWrite = base::File::FLAG_CREATE |
-                                 base::File::FLAG_WRITE |
-                                 base::File::FLAG_ASYNC;
+const int kOpenFlagsForWrite =
+    base::File::FLAG_OPEN | base::File::FLAG_WRITE | base::File::FLAG_ASYNC;
+const int kCreateFlagsForWrite =
+    base::File::FLAG_CREATE | base::File::FLAG_WRITE | base::File::FLAG_ASYNC;
 
 }  // namespace
 
 FileStreamWriter* FileStreamWriter::CreateForLocalFile(
     base::TaskRunner* task_runner,
     const base::FilePath& file_path,
     int64 initial_offset,
     OpenOrCreate open_or_create) {
   return new LocalFileStreamWriter(
       task_runner, file_path, initial_offset, open_or_create);
 }
 
 LocalFileStreamWriter::~LocalFileStreamWriter() {
   // Invalidate weak pointers so that we won't receive any callbacks from
   // in-flight stream operations, which might be triggered during the file close
   // in the FileStream destructor.
   weak_factory_.InvalidateWeakPtrs();
 
   // FileStream's destructor closes the file safely, since we opened the file
   // by its Open() method.
 }
 
-int LocalFileStreamWriter::Write(net::IOBuffer* buf, int buf_len,
+int LocalFileStreamWriter::Write(net::IOBuffer* buf,
+                                 int buf_len,
                                  const net::CompletionCallback& callback) {
   DCHECK(!has_pending_operation_);
   DCHECK(cancel_callback_.is_null());
 
   has_pending_operation_ = true;
   if (stream_impl_) {
     int result = InitiateWrite(buf, buf_len, callback);
     if (result != net::ERR_IO_PENDING)
       has_pending_operation_ = false;
     return result;
   }
   return InitiateOpen(callback,
                       base::Bind(&LocalFileStreamWriter::ReadyToWrite,
                                  weak_factory_.GetWeakPtr(),
-                                 make_scoped_refptr(buf), buf_len, callback));
+                                 make_scoped_refptr(buf),
+                                 buf_len,
+                                 callback));
 }
 
 int LocalFileStreamWriter::Cancel(const net::CompletionCallback& callback) {
   if (!has_pending_operation_)
     return net::ERR_UNEXPECTED;
 
   DCHECK(!callback.is_null());
   cancel_callback_ = callback;
   return net::ERR_IO_PENDING;
 }
@@ skipping 15 matching lines @@
 
 LocalFileStreamWriter::LocalFileStreamWriter(base::TaskRunner* task_runner,
                                              const base::FilePath& file_path,
                                              int64 initial_offset,
                                              OpenOrCreate open_or_create)
     : file_path_(file_path),
       open_or_create_(open_or_create),
       initial_offset_(initial_offset),
       task_runner_(task_runner),
       has_pending_operation_(false),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+}
 
 int LocalFileStreamWriter::InitiateOpen(
     const net::CompletionCallback& error_callback,
     const base::Closure& main_operation) {
   DCHECK(has_pending_operation_);
   DCHECK(!stream_impl_.get());
 
   stream_impl_.reset(new net::FileStream(task_runner_));
 
   int open_flags = 0;
   switch (open_or_create_) {
-  case OPEN_EXISTING_FILE:
-    open_flags = kOpenFlagsForWrite;
-    break;
-  case CREATE_NEW_FILE:
-    open_flags = kCreateFlagsForWrite;
-    break;
+    case OPEN_EXISTING_FILE:
+      open_flags = kOpenFlagsForWrite;
+      break;
+    case CREATE_NEW_FILE:
+      open_flags = kCreateFlagsForWrite;
+      break;
   }
 
   return stream_impl_->Open(file_path_,
                             open_flags,
                             base::Bind(&LocalFileStreamWriter::DidOpen,
                                        weak_factory_.GetWeakPtr(),
                                        error_callback,
                                        main_operation));
 }
 
@@ skipping 22 matching lines @@
     const base::Closure& main_operation) {
   DCHECK(has_pending_operation_);
   DCHECK(stream_impl_.get());
 
   if (initial_offset_ == 0) {
     // No need to seek.
     main_operation.Run();
     return;
   }
 
-  int result = stream_impl_->Seek(base::File::FROM_BEGIN, initial_offset_,
+  int result = stream_impl_->Seek(base::File::FROM_BEGIN,
+                                  initial_offset_,
                                   base::Bind(&LocalFileStreamWriter::DidSeek,
                                              weak_factory_.GetWeakPtr(),
                                              error_callback,
                                              main_operation));
   if (result != net::ERR_IO_PENDING) {
     has_pending_operation_ = false;
     error_callback.Run(result);
   }
 }
 
@@ skipping 14 matching lines @@
   if (result < 0) {
     has_pending_operation_ = false;
     error_callback.Run(static_cast<int>(result));
     return;
   }
 
   main_operation.Run();
 }
 
 void LocalFileStreamWriter::ReadyToWrite(
-    net::IOBuffer* buf, int buf_len,
+    net::IOBuffer* buf,
+    int buf_len,
     const net::CompletionCallback& callback) {
   DCHECK(has_pending_operation_);
 
   int result = InitiateWrite(buf, buf_len, callback);
   if (result != net::ERR_IO_PENDING) {
     has_pending_operation_ = false;
     callback.Run(result);
   }
 }
 
 int LocalFileStreamWriter::InitiateWrite(
-    net::IOBuffer* buf, int buf_len,
+    net::IOBuffer* buf,
+    int buf_len,
     const net::CompletionCallback& callback) {
   DCHECK(has_pending_operation_);
   DCHECK(stream_impl_.get());
 
-  return stream_impl_->Write(buf, buf_len,
+  return stream_impl_->Write(buf,
+                             buf_len,
                              base::Bind(&LocalFileStreamWriter::DidWrite,
                                         weak_factory_.GetWeakPtr(),
                                         callback));
 }
 
 void LocalFileStreamWriter::DidWrite(const net::CompletionCallback& callback,
                                      int result) {
   DCHECK(has_pending_operation_);
 
   if (CancelIfRequested())
     return;
   has_pending_operation_ = false;
   callback.Run(result);
 }
 
 int LocalFileStreamWriter::InitiateFlush(
     const net::CompletionCallback& callback) {
   DCHECK(has_pending_operation_);
   DCHECK(stream_impl_.get());
 
-  return stream_impl_->Flush(base::Bind(&LocalFileStreamWriter::DidFlush,
-                                        weak_factory_.GetWeakPtr(),
-                                        callback));
+  return stream_impl_->Flush(base::Bind(
+      &LocalFileStreamWriter::DidFlush, weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalFileStreamWriter::DidFlush(const net::CompletionCallback& callback,
                                      int result) {
   DCHECK(has_pending_operation_);
 
   if (CancelIfRequested())
     return;
   has_pending_operation_ = false;
   callback.Run(result);
 }
 
 bool LocalFileStreamWriter::CancelIfRequested() {
   DCHECK(has_pending_operation_);
 
   if (cancel_callback_.is_null())
     return false;
 
   net::CompletionCallback pending_cancel = cancel_callback_;
   has_pending_operation_ = false;
   cancel_callback_.Reset();
   pending_cancel.Run(net::OK);
   return true;
 }
 
-}  // namespace fileapi
+}  // namespace storage