Wrap large IndexedDB values into Blobs before writing to LevelDB.

third_party/WebKit/Source/modules/indexeddb/IDBValue.cpp

 // 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.
 
 #include "modules/indexeddb/IDBValue.h"
 
 #include "bindings/core/v8/serialization/SerializedScriptValue.h"
 #include "platform/blob/BlobData.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/WebBlobInfo.h"
@@ skipping 42 matching lines @@
           WTF::WrapUnique(new Vector<WebBlobInfo>(value->blob_info_->size()))),
       primary_key_(primary_key),
       key_path_(key_path) {
   for (size_t i = 0; i < value->blob_info_->size(); ++i) {
     const WebBlobInfo& info = (*blob_info_)[i] = value->blob_info_->at(i);
     blob_data_->push_back(
         BlobDataHandle::Create(info.Uuid(), info.GetType(), info.size()));
   }
 }
 
+IDBValue::IDBValue(PassRefPtr<SharedBuffer> unwrapped_data,
+                   std::unique_ptr<Vector<RefPtr<BlobDataHandle>>> blob_data,
+                   std::unique_ptr<Vector<WebBlobInfo>> blob_info)
+    : data_(std::move(unwrapped_data)),
+      blob_data_(std::move(blob_data)),
+      blob_info_(std::move(blob_info)) {}
+
 IDBValue::~IDBValue() {
   if (isolate_)
     isolate_->AdjustAmountOfExternalAllocatedMemory(-external_allocated_size_);
 }
 
 PassRefPtr<IDBValue> IDBValue::Create() {
   return AdoptRef(new IDBValue());
 }
 
 PassRefPtr<IDBValue> IDBValue::Create(const WebIDBValue& value,
                                       v8::Isolate* isolate) {
   return AdoptRef(new IDBValue(value, isolate));
 }
 
 PassRefPtr<IDBValue> IDBValue::Create(const IDBValue* value,
                                       IDBKey* primary_key,
                                       const IDBKeyPath& key_path) {
   return AdoptRef(new IDBValue(value, primary_key, key_path));
 }
 
+PassRefPtr<IDBValue> IDBValue::Create(
+    PassRefPtr<SharedBuffer> unwrapped_data,
+    std::unique_ptr<Vector<RefPtr<BlobDataHandle>>> blob_data,

[dcheng, 2017/05/25 18:34:04]

No need to fix in this CL, but:
1. Isn't Vector movable? It looks a bit odd to wrap it in a unique_ptr.
2. I think we're trying to get rid of PassRefPtr and just use RefPtr.

[pwnall, 2017/05/25 20:01:10]

Acknowledged.

I will look to fix both of these in a follow-up. Regarding the 2nd issue... I
tried to minimize introducing new PassRefPtrs, subject to the constraint that I
didn't want to change IDBValue. I would like to do that in a follow-up, and
remove the mental overhead of having to learn/remember how PassRefPtr works.

+    std::unique_ptr<Vector<WebBlobInfo>> blob_info) {
+  return AdoptRef(new IDBValue(std::move(unwrapped_data), std::move(blob_data),
+                               std::move(blob_info)));
+}
+
 Vector<String> IDBValue::GetUUIDs() const {
   Vector<String> uuids;
   uuids.ReserveCapacity(blob_info_->size());
   for (const auto& info : *blob_info_)
     uuids.push_back(info.Uuid());
   return uuids;
 }
 
 RefPtr<SerializedScriptValue> IDBValue::CreateSerializedValue() const {
   return SerializedScriptValue::Create(data_->Data(), data_->size());
 }
 
 bool IDBValue::IsNull() const {
   return !data_.Get();
 }
 
 }  // namespace blink