[Storage] Blob Storage Refactoring pt 1

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 "storage/browser/blob/blob_url_request_job.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 16 matching lines @@
 #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 "storage/browser/blob/file_stream_reader.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_url.h"
+#include "storage/common/data_element.h"
 
 namespace storage {
 
 namespace {
 
-bool IsFileType(BlobData::Item::Type type) {
+bool IsFileType(DataElement::Type type) {
   switch (type) {
-    case BlobData::Item::TYPE_FILE:
-    case BlobData::Item::TYPE_FILE_FILESYSTEM:
+    case DataElement::TYPE_FILE:
+    case DataElement::TYPE_FILE_FILESYSTEM:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace
 
 BlobURLRequestJob::BlobURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
-    const scoped_refptr<BlobData>& blob_data,
+    scoped_ptr<BlobDataSnapshot> blob_data,
     storage::FileSystemContext* file_system_context,
     base::MessageLoopProxy* file_thread_proxy)
     : net::URLRequestJob(request, network_delegate),
-      blob_data_(blob_data),
+      blob_data_(blob_data.Pass()),
       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),
       error_(false),
       byte_range_set_(false),
       weak_factory_(this) {
@@ skipping 95 matching lines @@
 void BlobURLRequestJob::DidStart() {
   error_ = false;
 
   // We only support GET request per the spec.
   if (request()->method() != "GET") {
     NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED);
     return;
   }
 
   // If the blob data is not present, bail out.
-  if (!blob_data_.get()) {
+  if (!blob_data_) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   }
 
   CountSize();
 }
 
 bool BlobURLRequestJob::AddItemLength(size_t index, int64 item_length) {
   if (item_length > kint64max - total_size_) {
     NotifyFailure(net::ERR_FAILED);
     return false;
   }
 
   // Cache the size and add it to the total size.
   DCHECK_LT(index, item_length_list_.size());
   item_length_list_[index] = item_length;
   total_size_ += item_length;
   return true;
 }
 
 void BlobURLRequestJob::CountSize() {
   pending_get_file_info_count_ = 0;
   total_size_ = 0;
-  item_length_list_.resize(blob_data_->items().size());
+  const auto& items = blob_data_->items();
+  item_length_list_.resize(items.size());
 
-  for (size_t i = 0; i < blob_data_->items().size(); ++i) {
-    const BlobData::Item& item = blob_data_->items().at(i);
+  for (size_t i = 0; i < items.size(); ++i) {
+    const BlobDataItem& item = *items.at(i);
     if (IsFileType(item.type())) {
       ++pending_get_file_info_count_;
       GetFileStreamReader(i)->GetLength(
           base::Bind(&BlobURLRequestJob::DidGetFileItemLength,
                      weak_factory_.GetWeakPtr(), i));
       continue;
     }
 
     if (!AddItemLength(i, item.length()))
       return;
@@ skipping 35 matching lines @@
     return;
 
   if (result == net::ERR_UPLOAD_FILE_CHANGED) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   } else if (result < 0) {
     NotifyFailure(result);
     return;
   }
 
-  DCHECK_LT(index, blob_data_->items().size());
-  const BlobData::Item& item = blob_data_->items().at(index);
+  const auto& items = blob_data_->items();
+  DCHECK_LT(index, items.size());
+  const BlobDataItem& item = *items.at(index);
   DCHECK(IsFileType(item.type()));
 
   uint64 file_length = result;
   uint64 item_offset = item.offset();
   uint64 item_length = item.length();
 
   if (item_offset > file_length) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   }
@@ skipping 11 matching lines @@
 
   if (!AddItemLength(index, item_length))
     return;
 
   if (--pending_get_file_info_count_ == 0)
     DidCountSize(net::OK);
 }
 
 void BlobURLRequestJob::Seek(int64 offset) {
   // Skip the initial items that are not in the range.
+  const auto& items = blob_data_->items();
   for (current_item_index_ = 0;
-       current_item_index_ < blob_data_->items().size() &&
+       current_item_index_ < items.size() &&
            offset >= item_length_list_[current_item_index_];
        ++current_item_index_) {
     offset -= item_length_list_[current_item_index_];
   }
 
   // Set the offset that need to jump to for the first item in the range.
   current_item_offset_ = offset;
 
   if (offset == 0)
     return;
 
   // Adjust the offset of the first stream if it is of file type.
-  const BlobData::Item& item = blob_data_->items().at(current_item_index_);
+  const BlobDataItem& item = *items.at(current_item_index_);
   if (IsFileType(item.type())) {
     DeleteCurrentFileReader();
     CreateFileStreamReader(current_item_index_, offset);
   }
 }
 
 bool BlobURLRequestJob::ReadItem() {
   // Are we done with reading all the blob data?
   if (remaining_bytes_ == 0)
     return true;
 
+  const auto& items = blob_data_->items();
   // If we get to the last item but still expect something to read, bail out
   // since something is wrong.
-  if (current_item_index_ >= blob_data_->items().size()) {
+  if (current_item_index_ >= items.size()) {
     NotifyFailure(net::ERR_FAILED);
     return false;
   }
 
   // Compute the bytes to read for current item.
   int bytes_to_read = ComputeBytesToRead();
 
   // If nothing to read for current item, advance to next item.
   if (bytes_to_read == 0) {
     AdvanceItem();
     return ReadItem();
   }
 
   // Do the reading.
-  const BlobData::Item& item = blob_data_->items().at(current_item_index_);
-  if (item.type() == BlobData::Item::TYPE_BYTES)
+  const BlobDataItem& item = *items.at(current_item_index_);
+  if (item.type() == DataElement::TYPE_BYTES)
     return ReadBytesItem(item, bytes_to_read);
   if (IsFileType(item.type())) {
     return ReadFileItem(GetFileStreamReader(current_item_index_),
                         bytes_to_read);
   }
   NOTREACHED();
   return false;
 }
 
 void BlobURLRequestJob::AdvanceItem() {
@@ skipping 15 matching lines @@
 
   // Subtract the remaining bytes.
   remaining_bytes_ -= result;
   DCHECK_GE(remaining_bytes_, 0);
 
   // Adjust the read buffer.
   read_buf_->DidConsume(result);
   DCHECK_GE(read_buf_->BytesRemaining(), 0);
 }
 
-bool BlobURLRequestJob::ReadBytesItem(const BlobData::Item& item,
+bool BlobURLRequestJob::ReadBytesItem(const BlobDataItem& item,
                                       int bytes_to_read) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
 
   memcpy(read_buf_->data(),
          item.bytes() + item.offset() + current_item_offset_,
          bytes_to_read);
 
   AdvanceBytesRead(bytes_to_read);
   return true;
 }
@@ skipping 164 matching lines @@
 
   response_info_.reset(new net::HttpResponseInfo());
   response_info_->headers = headers;
 
   set_expected_content_size(remaining_bytes_);
 
   NotifyHeadersComplete();
 }
 
 FileStreamReader* BlobURLRequestJob::GetFileStreamReader(size_t index) {
-  DCHECK_LT(index, blob_data_->items().size());
-  const BlobData::Item& item = blob_data_->items().at(index);
+  const auto& items = blob_data_->items();
+  DCHECK_LT(index, items.size());
+  const BlobDataItem& item = *items.at(index);
   if (!IsFileType(item.type()))
     return NULL;
   if (index_to_reader_.find(index) == index_to_reader_.end())
     CreateFileStreamReader(index, 0);
   DCHECK(index_to_reader_[index]);
   return index_to_reader_[index];
 }
 
 void BlobURLRequestJob::CreateFileStreamReader(size_t index,
                                                int64 additional_offset) {
-  DCHECK_LT(index, blob_data_->items().size());
-  const BlobData::Item& item = blob_data_->items().at(index);
+  const auto& items = blob_data_->items();
+  DCHECK_LT(index, items.size());
+  const BlobDataItem& item = *items.at(index);
   DCHECK(IsFileType(item.type()));
   DCHECK_EQ(0U, index_to_reader_.count(index));
 
   FileStreamReader* reader = NULL;
   switch (item.type()) {
-    case BlobData::Item::TYPE_FILE:
+    case DataElement::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:
+    case DataElement::TYPE_FILE_FILESYSTEM:
       reader = file_system_context_
                    ->CreateFileStreamReader(
                          storage::FileSystemURL(file_system_context_->CrackURL(
                              item.filesystem_url())),
                          item.offset() + additional_offset,
                          item.length() == std::numeric_limits<uint64>::max()
                              ? storage::kMaximumLength
                              : item.length() - additional_offset,
                          item.expected_modification_time())
                    .release();
       break;
     default:
       NOTREACHED();
   }
   DCHECK(reader);
   index_to_reader_[index] = reader;
 }
 
 }  // namespace storage