[BlobStorage] BlobMemoryController & tests

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 <stdint.h>
 
 #include <memory>
@@ skipping 25 matching lines @@
   // 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>;
   };
 
+  explicit BlobDataItem(std::unique_ptr<DataElement> item);

[michaeln, 2016/10/11 20:55:23]

do these need to be public? what are the new consumers that need to cons these
up?

the fact that they're private is a good indication to random readers that they
probably won't need to construct these objects themselves (from the point of
view of using the storage lib rather than implementing the storage lib).

[dmurph, 2016/10/13 00:39:29]

Done.

+  BlobDataItem(std::unique_ptr<DataElement> item,
+               const scoped_refptr<DataHandle>& data_handle);
+  BlobDataItem(std::unique_ptr<DataElement> item,
+               const scoped_refptr<DataHandle>& data_handle,
+               disk_cache::Entry* entry,
+               int disk_cache_stream_index,
+               int disk_cache_side_stream_index);
+
   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_t offset() const { return item_->offset(); }
   uint64_t 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(); }
   DataElement* data_element_ptr() { 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_; }
   int disk_cache_side_stream_index() const {
     return disk_cache_side_stream_index_;
   }
 
+  const scoped_refptr<DataHandle>& data_handle() const { return data_handle_; }
+
  private:
   friend class BlobDataBuilder;
   friend class BlobStorageContext;
   friend class base::RefCounted<BlobDataItem>;
   friend STORAGE_EXPORT void PrintTo(const BlobDataItem& x, ::std::ostream* os);
 
-  explicit BlobDataItem(std::unique_ptr<DataElement> item);
-  BlobDataItem(std::unique_ptr<DataElement> item,
-               const scoped_refptr<DataHandle>& data_handle);
-  BlobDataItem(std::unique_ptr<DataElement> item,
-               const scoped_refptr<DataHandle>& data_handle,
-               disk_cache::Entry* entry,
-               int disk_cache_stream_index,
-               int disk_cache_side_stream_index);
   virtual ~BlobDataItem();
 
   std::unique_ptr<DataElement> item_;
   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_;
   int disk_cache_stream_index_;  // For TYPE_DISK_CACHE_ENTRY.
   int disk_cache_side_stream_index_;  // For TYPE_DISK_CACHE_ENTRY.
 };
 
 STORAGE_EXPORT bool operator==(const BlobDataItem& a, const BlobDataItem& b);
 STORAGE_EXPORT bool operator!=(const BlobDataItem& a, const BlobDataItem& b);
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_BLOB_BLOB_DATA_ITEM_H_