Create blobs from Disk Cache entries.

storage/browser/blob/blob_data_item.h

 // Copyright (c) 2015 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.
 
 #ifndef STORAGE_BROWSER_BLOB_BLOB_DATA_ITEM_H_
 #define STORAGE_BROWSER_BLOB_BLOB_DATA_ITEM_H_
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
-#include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/data_element.h"
 
+namespace disk_cache {
+class Entry;
+}
+
 namespace storage {
 class BlobDataBuilder;
 class BlobStorageContext;
 
-// Ref counted blob item.  This class owns the backing data of the blob item.
-// The backing data is immutable, and cannot change after creation.
-// The purpose of this class is to allow the resource to stick around in the
-// snapshot even after the resource was swapped in the blob (either to disk or
-// to memory) by the BlobStorageContext.
+// Ref counted blob item. This class owns the backing data of the blob item. The
+// backing data is immutable, and cannot change after creation. The purpose of
+// this class is to allow the resource to stick around in the snapshot even
+// after the resource was swapped in the blob (either to disk or to memory) by
+// the BlobStorageContext.
 class STORAGE_EXPORT BlobDataItem : public base::RefCounted<BlobDataItem> {
  public:
+  // The DataHandle class is used to persist resources that are needed for
+  // reading this BlobDataItem. This object will stay around while any reads are
+  // pending. If all blobs with this item are deleted or the item is swapped for
+  // a different backend version (mem-to-disk or the reverse), then the item
+  // will be destructed after all pending reads are complete.
+  class DataHandle : public base::RefCounted<DataHandle> {
+   public:
+    virtual disk_cache::Entry* disk_cache_entry() const;

[dmurph, 2015/06/05 01:17:22]

Sorry, why does this need to be here?  To get the size?

Can we just put the size on creation in the DataElement?

Having this here doesn't make as much sense now, kind of defeats the purpose of
this generic class. Perhaps I've made everything worse o.O

[gavinp, 2015/06/05 15:10:34]

BlobDataItem needs an implementation of disk_cache_entry() for the same reason
it needs an implementation of path(). In the URL request, we have to access the
disk cache entry. So this is used for much more than the length, see the calls
to ReadData and GetDataSize in the url request code in this same CL.

If we're going to have a working splice, we need something refcounted that's
holding on to the disk cache entry. The disk cache entries themselves can be
accessed through a disk_cache::ScopedEntryPtr, which has behaviour as a
scoped_ptr<>, or alternative as a disk_cache::Entry*. In earlier revisions of
this patch in which splicing didn't work, it was fine to have a ScopedEntryPtr
just hanging off of the BlobDataItem. But that's no good anymore, since those
can't be copied; we need an interstitial refcounted object. That's why I put
this method on the DataHandle.

+
+   protected:
+    virtual ~DataHandle();
+
+   private:
+    friend class base::RefCounted<DataHandle>;
+  };
+
   DataElement::Type type() const { return item_->type(); }
   const char* bytes() const { return item_->bytes(); }
   const base::FilePath& path() const { return item_->path(); }
   const GURL& filesystem_url() const { return item_->filesystem_url(); }
   const std::string& blob_uuid() const { return item_->blob_uuid(); }
   uint64 offset() const { return item_->offset(); }
   uint64 length() const { return item_->length(); }
   const base::Time& expected_modification_time() const {
     return item_->expected_modification_time();
   }
   const DataElement& data_element() const { return *item_; }
   const DataElement* data_element_ptr() const { return item_.get(); }
 
+  disk_cache::Entry* disk_cache_entry() const {
+    return data_handle_ ? data_handle_->disk_cache_entry() : nullptr;
+  }
+  int disk_cache_stream_index() const { return disk_cache_stream_index_; }
+
  private:
   friend class BlobDataBuilder;
   friend class BlobStorageContext;
   friend class base::RefCounted<BlobDataItem>;
 
   BlobDataItem(scoped_ptr<DataElement> item);
   BlobDataItem(scoped_ptr<DataElement> item,
-               scoped_refptr<ShareableFileReference> file_handle);
+               const scoped_refptr<DataHandle>& data_handle);
+  BlobDataItem(scoped_ptr<DataElement> item,
+               const scoped_refptr<DataHandle>& data_handle,
+               int disk_cache_stream_index_);
   virtual ~BlobDataItem();
 
   scoped_ptr<DataElement> item_;
-  scoped_refptr<ShareableFileReference> file_handle_;
+  scoped_refptr<DataHandle> data_handle_;
+
+  int disk_cache_stream_index_;  // For TYPE_DISK_CACHE_ENTRY.
 };
 
 #if defined(UNIT_TEST)
 inline bool operator==(const BlobDataItem& a, const BlobDataItem& b) {
-  return a.data_element() == b.data_element();
+  return a.disk_cache_entry() == b.disk_cache_entry() &&
+         a.data_element() == b.data_element();
 }
 
 inline bool operator!=(const BlobDataItem& a, const BlobDataItem& b) {
   return !(a == b);
 }
 #endif  // defined(UNIT_TEST)
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_BLOB_BLOB_DATA_ITEM_H_