[BlobAsync] Disk support for blob storage

storage/browser/blob/shareable_blob_data_item.h

 // Copyright 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_SHAREABLE_BLOB_DATA_ITEM_H_
 #define STORAGE_BROWSER_BLOB_SHAREABLE_BLOB_DATA_ITEM_H_
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/hash.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "storage/common/data_element.h"
 
 namespace storage {
 class BlobDataItem;
 class InternalBlobData;
 
 // This class allows blob items to be shared between blobs, and is only used by
 // BlobStorageContext. This class contains both the blob data item and the uuids
 // of all the blobs using this item.
 // The data in this class (the item) is immutable, but the item itself can be
 // swapped out with an item with the same data but a different backing (think
 // RAM vs file backed).
-class ShareableBlobDataItem : public base::RefCounted<ShareableBlobDataItem> {
+class ShareableBlobDataItem
+    : public base::RefCountedThreadSafe<ShareableBlobDataItem> {

[michaeln, 2016/07/14 01:44:43]

Why does this need to be a threadsafe refcount? If this really is needed, seems
like BlobDataItem might also need a threadsafe refcount.

[dmurph, 2016/07/15 20:18:15]

We pass this to a file thread in the BlobMemoryController to write data to
files. We don't grab references to the BlobDataItem, so we don't need that to be
thread safe refcounted.

[michaeln, 2016/08/15 22:44:42]

But if the Shareable item can be deref'd on the background thread, can it also
be deleted on the background thread? If it is, the ref on its Item data member
will be decremented on the background thread.

  public:
-  ShareableBlobDataItem(const std::string& blob_uuid,
-                        const scoped_refptr<BlobDataItem>& item);
+  ShareableBlobDataItem(scoped_refptr<BlobDataItem> item);
 
   const scoped_refptr<BlobDataItem>& item();
 
+  // This is a unique auto-incrementing id assigned to this item on
+  // construction. It is used to keep track of this item in an LRU data
+  // structure for eviction to disk.
+  uint64_t item_id() const { return item_id_; }
+
   base::hash_set<std::string>& referencing_blobs() {
     return referencing_blobs_;
   }
 
  private:
-  friend class base::RefCounted<ShareableBlobDataItem>;
+  friend class base::RefCountedThreadSafe<ShareableBlobDataItem>;
   friend class InternalBlobData;
+  friend class BlobMemoryController;
+  friend class BlobStorageContext;
   ~ShareableBlobDataItem();
 
+  // This is a unique identifier for this ShareableBlobDataItem.
+  uint64_t item_id_;
   scoped_refptr<BlobDataItem> item_;
 
   base::hash_set<std::string> referencing_blobs_;
 
   DISALLOW_COPY_AND_ASSIGN(ShareableBlobDataItem);
 };
 
 }  // namespace storage
 #endif  // STORAGE_BROWSER_BLOB_SHAREABLE_BLOB_DATA_ITEM_H_