Factor out common Element struct from BlobData and ResourceRequestBody

webkit/blob/blob_storage_controller.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_storage_controller.h"
 
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/blob/blob_data.h"
 
@@ skipping 49 matching lines @@
   memory_usage_ -= target_blob_data->GetMemoryUsage();
 
   // The blob data is stored in the "canonical" way. That is, it only contains a
   // list of Data and File items.
   // 1) The Data item is denoted by the raw data and the range.
   // 2) The File item is denoted by the file path, the range and the expected
   //    modification time.
   // All the Blob items in the passing blob data are resolved and expanded into
   // a set of Data and File items.
 
-  DCHECK(item.length > 0);
-  switch (item.type) {
-    case BlobData::TYPE_DATA:
-      // WebBlobData does not allow partial data.
-      DCHECK(!(item.offset) && item.length == item.data.size());
-      target_blob_data->AppendData(item.data.c_str(), item.data.size());
+  DCHECK(item.length() > 0);
+  switch (item.type()) {
+    case BlobData::Item::TYPE_BYTES:
+      DCHECK(!item.offset());
+      target_blob_data->AppendData(item.bytes(), item.length());
       break;
-    case BlobData::TYPE_DATA_EXTERNAL:
-      DCHECK(!item.offset);
-      target_blob_data->AppendData(item.data_external, item.length);
+    case BlobData::Item::TYPE_FILE:
+      AppendFileItem(target_blob_data,
+                     item.path(),
+                     item.offset(),
+                     item.length(),
+                     item.expected_modification_time());
       break;
-    case BlobData::TYPE_FILE:
-      AppendFileItem(target_blob_data,
-                     item.file_path,
-                     item.offset,
-                     item.length,
-                     item.expected_modification_time);
-      break;
-    case BlobData::TYPE_BLOB:
-      BlobData* src_blob_data = GetBlobDataFromUrl(item.blob_url);
+    case BlobData::Item::TYPE_BLOB: {
+      BlobData* src_blob_data = GetBlobDataFromUrl(item.url());
       DCHECK(src_blob_data);
       if (src_blob_data)
         AppendStorageItems(target_blob_data,
                            src_blob_data,
-                           item.offset,
-                           item.length);
+                           item.offset(),
+                           item.length());
+      break;
+    }
+    default:
+      NOTREACHED();
       break;
   }
 
   memory_usage_ += target_blob_data->GetMemoryUsage();
 
   // If we're using too much memory, drop this blob.
   // TODO(michaeln): Blob memory storage does not yet spill over to disk,
   // until it does, we'll prevent memory usage over a max amount.
   if (memory_usage_ > kMaxMemoryUsage)
     RemoveBlob(url);
@@ skipping 65 matching lines @@
 void BlobStorageController::AppendStorageItems(
     BlobData* target_blob_data, BlobData* src_blob_data,
     uint64 offset, uint64 length) {
   DCHECK(target_blob_data && src_blob_data &&
          length != static_cast<uint64>(-1));
 
   std::vector<BlobData::Item>::const_iterator iter =
       src_blob_data->items().begin();
   if (offset) {
     for (; iter != src_blob_data->items().end(); ++iter) {
-      if (offset >= iter->length)
-        offset -= iter->length;
+      if (offset >= iter->length())
+        offset -= iter->length();
       else
         break;
     }
   }
 
   for (; iter != src_blob_data->items().end() && length > 0; ++iter) {
-    uint64 current_length = iter->length - offset;
+    uint64 current_length = iter->length() - offset;
     uint64 new_length = current_length > length ? length : current_length;
-    if (iter->type == BlobData::TYPE_DATA) {
+    if (iter->type() == BlobData::Item::TYPE_BYTES) {
       target_blob_data->AppendData(
-          iter->data.c_str() + static_cast<size_t>(iter->offset + offset),
+          iter->bytes() + static_cast<size_t>(iter->offset() + offset),
           static_cast<uint32>(new_length));
     } else {
-      DCHECK(iter->type == BlobData::TYPE_FILE);
+      DCHECK(iter->type() == BlobData::Item::TYPE_FILE);
       AppendFileItem(target_blob_data,
-                     iter->file_path,
-                     iter->offset + offset,
+                     iter->path(),
+                     iter->offset() + offset,
                      new_length,
-                     iter->expected_modification_time);
+                     iter->expected_modification_time());
     }
     length -= new_length;
     offset = 0;
   }
 }
 
 void BlobStorageController::AppendFileItem(
     BlobData* target_blob_data,
     const FilePath& file_path, uint64 offset, uint64 length,
     const base::Time& expected_modification_time) {
@@ skipping 14 matching lines @@
 bool BlobStorageController::DecrementBlobDataUsage(BlobData* blob_data) {
   BlobDataUsageMap::iterator found = blob_data_usage_count_.find(blob_data);
   DCHECK(found != blob_data_usage_count_.end());
   if (--(found->second))
     return false;  // Still in use
   blob_data_usage_count_.erase(found);
   return true;
 }
 
 }  // namespace webkit_blob