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

storage/browser/blob/blob_url_request_job.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/blob/blob_url_request_job.h"
+#include "storage/browser/blob/blob_url_request_job.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util_proxy.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_status.h"
-#include "webkit/browser/blob/file_stream_reader.h"
-#include "webkit/browser/fileapi/file_system_context.h"
-#include "webkit/browser/fileapi/file_system_url.h"
+#include "storage/browser/blob/file_stream_reader.h"
+#include "storage/browser/fileapi/file_system_context.h"
+#include "storage/browser/fileapi/file_system_url.h"
 
-namespace webkit_blob {
+namespace storage {
 
 namespace {
 
 bool IsFileType(BlobData::Item::Type type) {
   switch (type) {
     case BlobData::Item::TYPE_FILE:
     case BlobData::Item::TYPE_FILE_FILESYSTEM:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace
 
 BlobURLRequestJob::BlobURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     BlobData* blob_data,
-    fileapi::FileSystemContext* file_system_context,
+    storage::FileSystemContext* file_system_context,
     base::MessageLoopProxy* file_thread_proxy)
     : net::URLRequestJob(request, network_delegate),
       blob_data_(blob_data),
       file_system_context_(file_system_context),
       file_thread_proxy_(file_thread_proxy),
       total_size_(0),
       remaining_bytes_(0),
       pending_get_file_info_count_(0),
       current_item_index_(0),
       current_item_offset_(0),
@@ skipping 123 matching lines @@
 
 void BlobURLRequestJob::CountSize() {
   pending_get_file_info_count_ = 0;
   total_size_ = 0;
   item_length_list_.resize(blob_data_->items().size());
 
   for (size_t i = 0; i < blob_data_->items().size(); ++i) {
     const BlobData::Item& item = blob_data_->items().at(i);
     if (IsFileType(item.type())) {
       ++pending_get_file_info_count_;
-      GetFileStreamReader(i)->GetLength(
-          base::Bind(&BlobURLRequestJob::DidGetFileItemLength,
-                     weak_factory_.GetWeakPtr(), i));
+      GetFileStreamReader(i)
+          ->GetLength(base::Bind(&BlobURLRequestJob::DidGetFileItemLength,
+                                 weak_factory_.GetWeakPtr(),
+                                 i));
       continue;
     }
 
     if (!AddItemLength(i, item.length()))
       return;
   }
 
   if (pending_get_file_info_count_ == 0)
     DidCountSize(net::OK);
 }
 
 void BlobURLRequestJob::DidCountSize(int error) {
   DCHECK(!error_);
 
   // If an error occured, bail out.
   if (error != net::OK) {
     NotifyFailure(error);
     return;
   }
 
   // Apply the range requirement.
   if (!byte_range_.ComputeBounds(total_size_)) {
     NotifyFailure(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
     return;
   }
 
-  remaining_bytes_ = byte_range_.last_byte_position() -
-                     byte_range_.first_byte_position() + 1;
+  remaining_bytes_ =
+      byte_range_.last_byte_position() - byte_range_.first_byte_position() + 1;
   DCHECK_GE(remaining_bytes_, 0);
 
   // Do the seek at the beginning of the request.
   if (byte_range_.first_byte_position())
     Seek(byte_range_.first_byte_position());
 
   NotifySuccess();
 }
 
 void BlobURLRequestJob::DidGetFileItemLength(size_t index, int64 result) {
@@ skipping 193 matching lines @@
   return bytes_read;
 }
 
 int BlobURLRequestJob::ComputeBytesToRead() const {
   int64 current_item_length = item_length_list_[current_item_index_];
 
   int64 item_remaining = current_item_length - current_item_offset_;
   int64 buf_remaining = read_buf_->BytesRemaining();
   int64 max_remaining = std::numeric_limits<int>::max();
 
-  int64 min = std::min(std::min(std::min(item_remaining,
-                                         buf_remaining),
-                                         remaining_bytes_),
-                                         max_remaining);
+  int64 min = std::min(
+      std::min(std::min(item_remaining, buf_remaining), remaining_bytes_),
+      max_remaining);
 
   return static_cast<int>(min);
 }
 
 bool BlobURLRequestJob::ReadLoop(int* bytes_read) {
   // Read until we encounter an error or could not get the data immediately.
   while (remaining_bytes_ > 0 && read_buf_->BytesRemaining() > 0) {
     if (!ReadItem())
       return false;
   }
 
   *bytes_read = BytesReadCompleted();
   return true;
 }
 
 void BlobURLRequestJob::NotifySuccess() {
   net::HttpStatusCode status_code = net::HTTP_OK;
   if (byte_range_set_ && byte_range_.IsValid())
     status_code = net::HTTP_PARTIAL_CONTENT;
   HeadersCompleted(status_code);
 }
 
 void BlobURLRequestJob::NotifyFailure(int error_code) {
   error_ = true;
 
   // If we already return the headers on success, we can't change the headers
   // now. Instead, we just error out.
   if (response_info_) {
-    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                     error_code));
+    NotifyDone(
+        net::URLRequestStatus(net::URLRequestStatus::FAILED, error_code));
     return;
   }
 
   net::HttpStatusCode status_code = net::HTTP_INTERNAL_SERVER_ERROR;
   switch (error_code) {
     case net::ERR_ACCESS_DENIED:
       status_code = net::HTTP_FORBIDDEN;
       break;
     case net::ERR_FILE_NOT_FOUND:
       status_code = net::HTTP_NOT_FOUND;
@@ skipping 24 matching lines @@
   if (status_code == net::HTTP_OK || status_code == net::HTTP_PARTIAL_CONTENT) {
     std::string content_length_header(net::HttpRequestHeaders::kContentLength);
     content_length_header.append(": ");
     content_length_header.append(base::Int64ToString(remaining_bytes_));
     headers->AddHeader(content_length_header);
     if (status_code == net::HTTP_PARTIAL_CONTENT) {
       DCHECK(byte_range_set_);
       DCHECK(byte_range_.IsValid());
       std::string content_range_header(net::HttpResponseHeaders::kContentRange);
       content_range_header.append(": bytes ");
-      content_range_header.append(base::StringPrintf(
-          "%" PRId64 "-%" PRId64,
-          byte_range_.first_byte_position(), byte_range_.last_byte_position()));
+      content_range_header.append(
+          base::StringPrintf("%" PRId64 "-%" PRId64,
+                             byte_range_.first_byte_position(),
+                             byte_range_.last_byte_position()));
       content_range_header.append("/");
       content_range_header.append(base::StringPrintf("%" PRId64, total_size_));
       headers->AddHeader(content_range_header);
     }
     if (!blob_data_->content_type().empty()) {
       std::string content_type_header(net::HttpRequestHeaders::kContentType);
       content_type_header.append(": ");
       content_type_header.append(blob_data_->content_type());
       headers->AddHeader(content_type_header);
     }
@@ skipping 34 matching lines @@
   switch (item.type()) {
     case BlobData::Item::TYPE_FILE:
       reader = FileStreamReader::CreateForLocalFile(
           file_thread_proxy_.get(),
           item.path(),
           item.offset() + additional_offset,
           item.expected_modification_time());
       break;
     case BlobData::Item::TYPE_FILE_FILESYSTEM:
       reader = file_system_context_->CreateFileStreamReader(
-          fileapi::FileSystemURL(
-              file_system_context_->CrackURL(item.filesystem_url())),
-          item.offset() + additional_offset,
-          item.expected_modification_time()).release();
+                                         storage::FileSystemURL(
+                                             file_system_context_->CrackURL(
+                                                 item.filesystem_url())),
+                                         item.offset() + additional_offset,
+                                         item.expected_modification_time())
+                   .release();
       break;
     default:
       NOTREACHED();
   }
   DCHECK(reader);
   index_to_reader_[index] = reader;
 }
 
-}  // namespace webkit_blob
+}  // namespace storage