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"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "storage/browser/blob/blob_data_builder.h"
+#include "storage/browser/blob/shareable_file_reference.h"
 #include "url/gurl.h"
 
 namespace storage {
 
 namespace {
 
 // We can't use GURL directly for these hash fragment manipulations
 // since it doesn't have specific knowlege of the BlobURL format. GURL
 // treats BlobURLs as if they were PathURLs which don't support hash
 // fragments.
@@ skipping 247 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.
+      NOTREACHED();
+      break;
     default:
       NOTREACHED();
       break;
   }
 
   return blob_item;
 }
 
 bool BlobStorageContext::AppendAllocatedBlobItem(
     const std::string& target_blob_uuid,
@@ skipping 62 matching lines @@
           GetBlobDataFromUUID(data_element.blob_uuid());
       if (src) {
         BlobMapEntry* other_entry =
             blob_map_.find(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 36 matching lines @@
 
     // We need to do copying of the items when we have a different offset or
     // length
     switch (item.type()) {
       case DataElement::TYPE_BYTES: {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.Bytes",
                              new_length / 1024);
         if (memory_usage_ + new_length > kMaxMemoryUsage) {
           return false;
         }
         DCHECK(!item.offset());

[michaeln, 2015/06/15 22:17:23]

gavinp: looks like it is only because of this

[gavinp, 2015/06/16 16:07:47]

Aha, thanks.

         scoped_ptr<DataElement> element(new DataElement());
         element->SetToBytes(item.bytes() + offset,

[gavinp, 2015/06/15 14:01:19]

michaeln: Your comment below on line 468 got me wondering if this is OK?

                             static_cast<int64>(new_length));
         memory_usage_ += new_length;
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
             target_blob_uuid, new BlobDataItem(element.Pass())));
       } break;
       case DataElement::TYPE_FILE: {
         DCHECK_NE(item.length(), std::numeric_limits<uint64>::max())
             << "We cannot use a section of a file with an unknown length";
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.File",
                              new_length / 1024);
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToFilePathRange(item.path(), item.offset() + offset,
                                     new_length,
                                     item.expected_modification_time());
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
             target_blob_uuid,
-            new BlobDataItem(element.Pass(), item.file_handle_)));
+            new BlobDataItem(element.Pass(), item.data_handle_)));
       } break;
       case DataElement::TYPE_FILE_FILESYSTEM: {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.FileSystem",
                              new_length / 1024);
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToFileSystemUrlRange(item.filesystem_url(),
                                          item.offset() + offset, new_length,
                                          item.expected_modification_time());
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
             target_blob_uuid, new BlobDataItem(element.Pass())));
       } break;
+      case DataElement::TYPE_DISK_CACHE_ENTRY: {
+        scoped_ptr<DataElement> element(new DataElement());
+        element->SetToDiskCacheEntryRange(item.length() + offset,

[michaeln, 2015/06/12 23:43:06]

should this be item.offset() + offset ?

[gavinp, 2015/06/15 14:01:19]

Done.

+                                          new_length);
+        target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
+            target_blob_uuid,
+            new BlobDataItem(element.Pass(), item.data_handle_,
+                             item.disk_cache_entry(),
+                             item.disk_cache_stream_index())));
+      } break;
       default:
         CHECK(false) << "Illegal blob item type: " << item.type();
     }
     length -= new_length;
     offset = 0;
   }
   return true;
 }
 
 bool BlobStorageContext::IsInUse(const std::string& uuid) {
   return blob_map_.find(uuid) != blob_map_.end();
 }
 
 bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) {
   BlobMap::iterator found = blob_map_.find(uuid);
   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