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 STORAGE_EXPORT DataHandle : public base::RefCounted<DataHandle> {
+   protected:
+    virtual ~DataHandle() = 0;
+
+   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 disk_cache_entry_; }
+  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,
+               disk_cache::Entry* entry,
+               int disk_cache_stream_index_);
   virtual ~BlobDataItem();
 
   scoped_ptr<DataElement> item_;
-  scoped_refptr<ShareableFileReference> file_handle_;
+  scoped_refptr<DataHandle> data_handle_;
+
+  // This naked pointer is safe because the scope is protected by the DataHandle
+  // instance for disk cache entries during the lifetime of this BlobDataItem.
+  disk_cache::Entry* disk_cache_entry_;

[michaeln, 2015/06/16 21:52:54]

This special case is icky. Its here only because there's no place to put it in
the storage::DataElement struct.

[gavinp, 2015/06/16 22:28:02]

Yes. In an earlier revision of this CL, the DataHandle had a method
disk_cache_entry() which returned NULL by default, but was overridden in the
instance for the CacheStorageCache to return non-NULL. This avoided storing two
pointers and the scary naked pointer, but it did mean the clean abstraction of
DataHandle() was broken with this specific information about one use case.

dmurph and I had a VC to talk about that design, and eventually he suggested I
proceed as you see with the naked pointer. If you look up in the patch sets you
can still see the earlier version of this.

[dmurph, 2015/06/16 22:38:41]

Michael: ideally, we don't really *need* the DataElement struct, it's just handy
because that's how the data is transported.  Putting the resources in
BlobDataItem makes perfect sense in our refcounting resource model now.  Any new
blob storage backing should be thrown in here, and then lifetime for that
resources abstracted away by using a custom DataHandle.

[gavinp, 2015/06/16 22:42:45]

Also worth mentioning: We can't put a member of disk_cache::Entry* type in
DataElement at all, because it's defined in a common/ directory. If it doesn't
break a presubmit include rule, it should.

+  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.disk_cache_stream_index() == b.disk_cache_stream_index() &&
+         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_