[BlobAsync] Moving async handling into BlobStorageContext & quota out.

storage/browser/blob/blob_entry.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_BLOB_ENTRY_H_
+#define STORAGE_BROWSER_BLOB_BLOB_ENTRY_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/callback_forward.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/optional.h"
+#include "storage/browser/blob/blob_memory_controller.h"
+#include "storage/browser/storage_browser_export.h"
+
+namespace storage {
+class BlobDataHandle;
+class ShareableBlobDataItem;
+class ViewBlobInternalsJob;
+
+// This class represents a blob in BlobStorageRegistry. We export this only for
+// unit tests.
+class STORAGE_EXPORT BlobEntry {
+ public:
+  using TransportAllowedCallback =
+      base::Callback<void(BlobStatus,
+                          std::vector<BlobMemoryController::FileCreationInfo>)>;
+
+  // This records a copy from a referenced blob. When we finish building our
+  // blob we perform all of these copies.
+  struct STORAGE_EXPORT ItemCopyEntry {
+    ItemCopyEntry(scoped_refptr<ShareableBlobDataItem> source_item,
+                  size_t source_item_offset,
+                  scoped_refptr<ShareableBlobDataItem> dest_item);
+    ~ItemCopyEntry();
+    ItemCopyEntry(ItemCopyEntry&& other);
+    BlobEntry::ItemCopyEntry& operator=(BlobEntry::ItemCopyEntry&& rhs);
+
+    scoped_refptr<ShareableBlobDataItem> source_item;
+    size_t source_item_offset = 0;
+    scoped_refptr<ShareableBlobDataItem> dest_item;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ItemCopyEntry);
+  };
+
+  // This keeps track of our building state for our blob. While building, four
+  // things can be happening mostly simultaneously:
+  // 1. Waiting for quota to be reserved for memory needed (PENDING_QUOTA)
+  // 2. Waiting for user population of data after quota (PENDING_TRANSPORT)
+  // 3. Waiting for blobs we reference to complete (PENDING_INTERNALS)
+  struct STORAGE_EXPORT BuildingState {
+    // |transport_allowed_callback| is not null when data needs population. See
+    // BlobStorageContext::BuildBlob for when the callback is called.
+    BuildingState(bool transport_items_present,
+                  TransportAllowedCallback transport_allowed_callback,
+                  size_t num_building_dependent_blobs);
+    ~BuildingState();
+
+    const bool transport_items_present;
+    // We can have trasnport data that's either populated or unpopulated. If we
+    // need population, this is populated.
+    TransportAllowedCallback transport_allowed_callback;
+    std::vector<ShareableBlobDataItem*> transport_items;
+
+    // Stores all blobs that we're depending on for building. This keeps the
+    // blobs alive while we build our blob.
+    std::vector<std::unique_ptr<BlobDataHandle>> dependent_blobs;
+    size_t num_building_dependent_blobs;
+
+    base::WeakPtr<BlobMemoryController::QuotaAllocationTask>
+        memory_quota_request;
+
+    // These are copies from a referenced blob item to our blob items. Some of
+    // these entries may have changed from bytes to files if they were paged.
+    std::vector<ItemCopyEntry> copies;
+
+    // When our blob finishes building these callbacks are called.
+    std::vector<BlobStatusCallback> build_completion_callbacks;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(BuildingState);
+  };
+
+  BlobEntry(const std::string& content_type,
+            const std::string& content_disposition);
+  ~BlobEntry();
+
+  // Appends the given shared blob data item to this object. We add |my_uuid|
+  // to the shareable item's uuid set.

[kinuko, 2016/11/17 07:53:01]

Comment looks stale

[dmurph, 2016/11/17 18:05:23]

Done.

+  void AppendSharedBlobItem(scoped_refptr<ShareableBlobDataItem> item);
+
+  // Returns if we're a pending blob that can finish building.
+  bool CanFinishBuilding() const {
+    return status_ == BlobStatus::PENDING_INTERNALS &&
+           building_state_->num_building_dependent_blobs == 0;
+  }
+
+  BlobStatus status() const { return status_; }
+
+  size_t refcount() const { return refcount_; }
+
+  const std::string& content_type() const { return content_type_; }
+
+  const std::string& content_disposition() const {
+    return content_disposition_;
+  }
+
+  // Total size of this blob in bytes.
+  uint64_t total_size() const { return size_; };
+
+  // We record the cumulative offsets of each blob item (except for the first,
+  // which would always be 0) to enable binary searching for an item at a
+  // specific byte offset.
+  const std::vector<uint64_t>& offsets() const { return offsets_; }
+
+  const std::vector<scoped_refptr<ShareableBlobDataItem>>& items() const;
+
+ protected:
+  friend class BlobStorageContext;
+
+  void IncrementRefCount() { ++refcount_; }
+  void DecrementRefCount() { --refcount_; }
+
+  void set_status(BlobStatus status) { status_ = status; }
+  void set_size(uint64_t size) { size_ = size; }
+
+  void ClearItems();
+  void ClearOffsets();
+
+  void set_building_state(std::unique_ptr<BuildingState> building_state) {
+    building_state_ = std::move(building_state);
+  }
+
+ private:
+  BlobStatus status_ = BlobStatus::PENDING_QUOTA;
+  size_t refcount_ = 0;
+
+  // Metadata.
+  std::string content_type_;
+  std::string content_disposition_;
+
+  std::vector<scoped_refptr<ShareableBlobDataItem>> items_;
+
+  // Size in bytes. IFF we're a single file then this can be uint64_max.
+  uint64_t size_ = 0;
+
+  // Only populated if len(items_) > 1.  Used for binary search.
+  // Since the offset of the first item is always 0, we exclude this.
+  std::vector<uint64_t> offsets_;
+
+  // Only populated if our status is PENDING_*.
+  std::unique_ptr<BuildingState> building_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobEntry);
+};
+
+}  // namespace storage
+#endif  // STORAGE_BROWSER_BLOB_BLOB_ENTRY_H_