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

storage/browser/fileapi/quota/quota_reservation.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/quota/quota_reservation.h"
+#include "storage/browser/fileapi/quota/quota_reservation.h"
 
 #include "base/bind.h"
-#include "webkit/browser/fileapi/quota/open_file_handle.h"
-#include "webkit/browser/fileapi/quota/quota_reservation_buffer.h"
+#include "storage/browser/fileapi/quota/open_file_handle.h"
+#include "storage/browser/fileapi/quota/quota_reservation_buffer.h"
 
-namespace fileapi {
+namespace storage {
 
-void QuotaReservation::RefreshReservation(
-    int64 size,
-    const StatusCallback& callback) {
+void QuotaReservation::RefreshReservation(int64 size,
+                                          const StatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!running_refresh_request_);
   DCHECK(!client_crashed_);
   if (!reservation_manager())
     return;
 
   running_refresh_request_ = true;
 
   reservation_manager()->ReserveQuota(
-      origin(), type(), size - remaining_quota_,
+      origin(),
+      type(),
+      size - remaining_quota_,
       base::Bind(&QuotaReservation::AdaptDidUpdateReservedQuota,
                  weak_ptr_factory_.GetWeakPtr(),
-                 remaining_quota_, callback));
+                 remaining_quota_,
+                 callback));
 
   if (running_refresh_request_)
     remaining_quota_ = 0;
 }
 
 scoped_ptr<OpenFileHandle> QuotaReservation::GetOpenFileHandle(
     const base::FilePath& platform_path) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!client_crashed_);
   return reservation_buffer_->GetOpenFileHandle(this, platform_path);
@@ skipping 25 matching lines @@
 }
 
 const GURL& QuotaReservation::origin() const {
   return reservation_buffer_->origin();
 }
 
 FileSystemType QuotaReservation::type() const {
   return reservation_buffer_->type();
 }
 
-QuotaReservation::QuotaReservation(
-    QuotaReservationBuffer* reservation_buffer)
+QuotaReservation::QuotaReservation(QuotaReservationBuffer* reservation_buffer)
     : client_crashed_(false),
       running_refresh_request_(false),
       remaining_quota_(0),
       reservation_buffer_(reservation_buffer),
       weak_ptr_factory_(this) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 }
 
 QuotaReservation::~QuotaReservation() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
@@ skipping 11 matching lines @@
     const StatusCallback& callback,
     base::File::Error error,
     int64 delta) {
   if (!reservation)
     return false;
 
   return reservation->DidUpdateReservedQuota(
       previous_size, callback, error, delta);
 }
 
-bool QuotaReservation::DidUpdateReservedQuota(
-    int64 previous_size,
-    const StatusCallback& callback,
-    base::File::Error error,
-    int64 delta) {
+bool QuotaReservation::DidUpdateReservedQuota(int64 previous_size,
+                                              const StatusCallback& callback,
+                                              base::File::Error error,
+                                              int64 delta) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(running_refresh_request_);
   running_refresh_request_ = false;
 
   if (client_crashed_) {
     callback.Run(base::File::FILE_ERROR_ABORT);
     return false;
   }
 
   if (error == base::File::FILE_OK)
     remaining_quota_ = previous_size + delta;
   callback.Run(error);
   return true;
 }
 
-}  // namespace fileapi
+}  // namespace storage