Factor out common Element struct from BlobData and ResourceRequestBody

webkit/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/blob/blob_url_request_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
@@ skipping 158 matching lines @@
 }
 
 void BlobURLRequestJob::CountSize() {
   error_ = false;
   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 (item.type == BlobData::TYPE_FILE) {
+    if (item.type() == BlobData::Item::TYPE_FILE) {
       ++pending_get_file_info_count_;
       GetFileStreamReader(i)->GetLength(
           base::Bind(&BlobURLRequestJob::DidGetFileItemLength,
                      weak_factory_.GetWeakPtr(), i));
       continue;
     }
     // Cache the size and add it to the total size.
-    int64 item_length = static_cast<int64>(item.length);
+    int64 item_length = static_cast<int64>(item.length());
     item_length_list_[i] = item_length;
     total_size_ += item_length;
   }
 
   if (pending_get_file_info_count_ == 0)
     DidCountSize(net::OK);
 }
 
 void BlobURLRequestJob::DidCountSize(int error) {
   DCHECK(!error_);
@@ skipping 29 matching lines @@
   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);
-  DCHECK(item.type == BlobData::TYPE_FILE);
+  DCHECK(item.type() == BlobData::Item::TYPE_FILE);
 
   // If item length is -1, we need to use the file size being resolved
   // in the real time.
-  int64 item_length = static_cast<int64>(item.length);
+  int64 item_length = static_cast<int64>(item.length());
   if (item_length == -1)
-    item_length = result - item.offset;
+    item_length = result - item.offset();
 
   // 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;
 
   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.
   for (current_item_index_ = 0;
        current_item_index_ < blob_data_->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_);
-  if (item.type == BlobData::TYPE_FILE) {
+  if (item.type() == BlobData::Item::TYPE_FILE) {
     DeleteCurrentFileReader();
     index_to_reader_[current_item_index_] = new LocalFileStreamReader(
         file_thread_proxy_,
-        item.file_path,
-        item.offset + offset,
-        item.expected_modification_time);
+        item.path(),
+        item.offset() + offset,
+        item.expected_modification_time());
   }
 }
 
 bool BlobURLRequestJob::ReadItem() {
   // Are we done with reading all the blob data?
   if (remaining_bytes_ == 0)
     return true;
 
   // 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()) {
     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_);
-  switch (item.type) {
-    case BlobData::TYPE_DATA:
+  switch (item.type()) {
+    case BlobData::Item::TYPE_BYTES:
       return ReadBytesItem(item, bytes_to_read);
-    case BlobData::TYPE_FILE:
+    case BlobData::Item::TYPE_FILE:
       return ReadFileItem(GetFileStreamReader(current_item_index_),
                           bytes_to_read);
     default:
       DCHECK(false);
       return false;
   }
 }
 
 void BlobURLRequestJob::AdvanceItem() {
   // Close the file if the current item is a file.
@@ skipping 19 matching lines @@
   // Adjust the read buffer.
   read_buf_->DidConsume(result);
   DCHECK_GE(read_buf_->BytesRemaining(), 0);
 }
 
 bool BlobURLRequestJob::ReadBytesItem(const BlobData::Item& item,
                                       int bytes_to_read) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
 
   memcpy(read_buf_->data(),
-         &item.data.at(0) + item.offset + current_item_offset_,
+         item.bytes() + item.offset() + current_item_offset_,
          bytes_to_read);
 
   AdvanceBytesRead(bytes_to_read);
   return true;
 }
 
 bool BlobURLRequestJob::ReadFileItem(LocalFileStreamReader* reader,
                                      int bytes_to_read) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
   DCHECK(reader);
@@ skipping 162 matching lines @@
 
   set_expected_content_size(remaining_bytes_);
   headers_set_ = true;
 
   NotifyHeadersComplete();
 }
 
 LocalFileStreamReader* BlobURLRequestJob::GetFileStreamReader(size_t index) {
   DCHECK_LT(index, blob_data_->items().size());
   const BlobData::Item& item = blob_data_->items().at(index);
-  if (item.type != BlobData::TYPE_FILE)
+  if (item.type() != BlobData::Item::TYPE_FILE)
     return NULL;
   if (index_to_reader_.find(index) == index_to_reader_.end()) {
     index_to_reader_[index] = new LocalFileStreamReader(
         file_thread_proxy_,
-        item.file_path,
-        item.offset,
-        item.expected_modification_time);
+        item.path(),
+        item.offset(),
+        item.expected_modification_time());
   }
   DCHECK(index_to_reader_[index]);
   return index_to_reader_[index];
 }
 
 }  // namespace webkit_blob