Create blobs from Disk Cache entries.

storage/browser/blob/blob_storage_context.cc

 // Copyright (c) 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 "storage/browser/blob/blob_storage_context.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 77 matching lines @@
       public_blob_urls_.find(BlobUrlHasRef(url) ? ClearBlobUrlRef(url) : url);
   if (found == public_blob_urls_.end())
     return scoped_ptr<BlobDataHandle>();
   return GetBlobDataFromUUID(found->second);
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob(
     BlobDataBuilder* external_builder) {
   TRACE_EVENT0("Blob", "Context::AddFinishedBlob");
   StartBuildingBlob(external_builder->uuid_);
+  DCHECK_EQ(1U, blob_map_.count(external_builder->uuid_));

[jkarlin, 2015/05/29 14:59:41]

Why this change?

[gavinp, 2015/05/29 18:06:07]

I don't like doing DCHECK with == or != in them; it's best to use DCHECK_EQ, for
better printouts on failure. That's not relevant in this case though; as both
will have equally useful debug dumps. The other advantage to this formulation is
safety; the DCHECK is before any possible dereference, but that's pretty minor.

I've moved it back.

   BlobMap::iterator found = blob_map_.find(external_builder->uuid_);
-  DCHECK(found != blob_map_.end());
   BlobMapEntry* entry = found->second;
   InternalBlobData::Builder* target_blob_builder = entry->data_builder.get();
   DCHECK(target_blob_builder);
 
   target_blob_builder->set_content_disposition(
       external_builder->content_disposition_);
   for (const auto& blob_item : external_builder->items_) {
     if (!AppendAllocatedBlobItem(external_builder->uuid_, blob_item,
                                  target_blob_builder)) {
       BlobEntryExceededMemory(entry);
@@ skipping 166 matching lines @@
                                        ipc_data.offset(), length,
                                        ipc_data.expected_modification_time());
       blob_item = new BlobDataItem(element.Pass());
       break;
     case DataElement::TYPE_BLOB:
       // This is a temporary item that will be deconstructed later.
       element->SetToBlobRange(ipc_data.blob_uuid(), ipc_data.offset(),
                               ipc_data.length());
       blob_item = new BlobDataItem(element.Pass());
       break;
+    case DataElement::TYPE_DISK_CACHE_ENTRY:  // This type can't be sent by IPC.

[jkarlin, 2015/05/29 14:59:42]

Add NOTREACHED().

[gavinp, 2015/05/29 18:06:07]

Done.

     default:
       NOTREACHED();
       break;
   }
 
   return blob_item;
 }
 
 bool BlobStorageContext::AppendAllocatedBlobItem(
     const std::string& target_blob_uuid,
     scoped_refptr<BlobDataItem> blob_item,
     InternalBlobData::Builder* target_blob_builder) {
   bool exceeded_memory = false;
 
   // The blob data is stored in the canonical way which only contains a
   // list of Data, File, and FileSystem items. Aggregated TYPE_BLOB items
   // are expanded into the primitive constituent types and reused if possible.
   // 1) The Data item is denoted by the raw data and length.
   // 2) The File item is denoted by the file path, the range and the expected
   //    modification time.
   // 3) The FileSystem File item is denoted by the FileSystem URL, the range
   //    and the expected modification time.

[jkarlin, 2015/05/29 14:59:42]

Add your new type's description to this comment as well.

[gavinp, 2015/05/29 18:06:07]

Done.

This is why I hate comments like this.

   // 4) The Blob item is denoted by the source blob and an offset and size.
   //    Internal items that are fully used by the new blob (not cut by the
   //    offset or size) are shared between the blobs.  Otherwise, the relevant
   //    portion of the item is copied.
 
-  const DataElement& data_element = blob_item->data_element();
-  uint64 length = data_element.length();
-  uint64 offset = data_element.offset();
+  uint64 length = blob_item->GetLength();
+  uint64 offset = blob_item->GetOffset();
   UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend",
                        memory_usage_ / 1024);
-  switch (data_element.type()) {
+  switch (blob_item->data_element().type()) {
     case DataElement::TYPE_BYTES:
       UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length / 1024);
       DCHECK(!offset);
       if (memory_usage_ + length > kMaxMemoryUsage) {
         exceeded_memory = true;
         break;
       }
       memory_usage_ += length;
       target_blob_builder->AppendSharedBlobItem(
           new ShareableBlobDataItem(target_blob_uuid, blob_item));
@@ skipping 19 matching lines @@
       }
       target_blob_builder->AppendSharedBlobItem(
           new ShareableBlobDataItem(target_blob_uuid, blob_item));
       break;
     }
     case DataElement::TYPE_BLOB: {
       UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob",
                            (length - offset) / 1024);
       // We grab the handle to ensure it stays around while we copy it.
       scoped_ptr<BlobDataHandle> src =
-          GetBlobDataFromUUID(data_element.blob_uuid());
+          GetBlobDataFromUUID(blob_item->data_element().blob_uuid());
       if (src) {
         BlobMapEntry* other_entry =
-            blob_map_.find(data_element.blob_uuid())->second;
+            blob_map_.find(blob_item->data_element().blob_uuid())->second;
         DCHECK(other_entry->data);
         exceeded_memory = !AppendBlob(target_blob_uuid, *other_entry->data,
                                       offset, length, target_blob_builder);
       }
       break;
     }
+    case DataElement::TYPE_DISK_CACHE_ENTRY: {
+      UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.CacheEntry",
+                           (length - offset) / 1024);
+      target_blob_builder->AppendSharedBlobItem(
+          new ShareableBlobDataItem(target_blob_uuid, blob_item));
+      break;
+    }
     default:
       NOTREACHED();
       break;
   }
   UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend",
                        memory_usage_ / 1024);
 
   return !exceeded_memory;
 }
 
@@ skipping 18 matching lines @@
   }
 
   for (; iter != items.end() && length > 0; ++iter) {
     scoped_refptr<ShareableBlobDataItem> shareable_item = iter->get();
     const BlobDataItem& item = *(shareable_item->item());
     uint64_t item_length = item.GetLength();
     DCHECK_GT(item_length, offset);
     uint64_t current_length = item_length - offset;
     uint64_t new_length = current_length > length ? length : current_length;
 
-    bool reusing_blob_item = offset == 0 && new_length == item_length;
+    // Always reuse disk cache entries, as they never have an offset or length.
+    bool reusing_blob_item =
+        item.type() == DataElement::TYPE_DISK_CACHE_ENTRY ||
+        (offset == 0 && new_length == item_length);
     UMA_HISTOGRAM_BOOLEAN("Storage.Blob.ReusedItem", reusing_blob_item);
     if (reusing_blob_item) {
       shareable_item->referencing_blobs().insert(target_blob_uuid);
       target_blob_builder->AppendSharedBlobItem(shareable_item);
       length -= new_length;
       continue;
     }
 
     // We need to do copying of the items when we have a different offset or
     // length
@@ skipping 53 matching lines @@
   if (found == blob_map_.end())
     return false;
   return found->second->IsBeingBuilt();
 }
 
 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
   return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
 }
 
 }  // namespace storage