[IndexedDB] Hold referenced to IDB::put blobs in the IDBRequest

third_party/WebKit/Source/modules/indexeddb/IDBRequest.h

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 11 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef IDBRequest_h
 #define IDBRequest_h
 
+#include <memory>
+
 #include "bindings/core/v8/ActiveScriptWrappable.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "core/dom/DOMStringList.h"
 #include "core/dom/SuspendableObject.h"
 #include "core/events/EventListener.h"
 #include "core/events/EventTarget.h"
 #include "modules/EventModules.h"
 #include "modules/ModulesExport.h"
 #include "modules/indexeddb/IDBAny.h"
 #include "modules/indexeddb/IDBTransaction.h"
 #include "modules/indexeddb/IndexedDB.h"
 #include "platform/blob/BlobData.h"
 #include "platform/heap/Handle.h"
+#include "platform/wtf/HashMap.h"
 #include "public/platform/WebBlobInfo.h"
 #include "public/platform/modules/indexeddb/WebIDBCursor.h"
 #include "public/platform/modules/indexeddb/WebIDBTypes.h"
-#include <memory>
 
 namespace blink {
 
 class DOMException;
 class ExceptionState;
 class IDBCursor;
 struct IDBDatabaseMetadata;
 class IDBValue;
 
 class MODULES_EXPORT IDBRequest : public EventTargetWithInlineData,
@@ skipping 74 matching lines @@
   ExecutionContext* GetExecutionContext() const final;
   void UncaughtExceptionInEventHandler() final;
 
   // Called by a version change transaction that has finished to set this
   // request back from DONE (following "upgradeneeded") back to PENDING (for
   // the upcoming "success" or "error").
   void TransactionDidFinishAndDispatch();
 
   IDBCursor* GetResultCursor() const;
 
+  void StorePutOperationBlobs(

[michaeln, 2017/04/25 23:37:00]

nit: consider naming the StoreXXX and ClearXXX methods with the same noun at the
end

[dmurph, 2017/04/27 22:04:12]

Done.

+      HashMap<String, RefPtr<BlobDataHandle>> blob_handles) {
+    transit_blob_handles_ = std::move(blob_handles);
+  }
+
  protected:
   IDBRequest(ScriptState*, IDBAny* source, IDBTransaction*);
   void EnqueueEvent(Event*);
   void DequeueEvent(Event*);
   virtual bool ShouldEnqueueEvent() const;
   void OnSuccessInternal(IDBAny*);
   void SetResult(IDBAny*);
 
   // EventTarget
   DispatchEventResult DispatchEventInternal(Event*) override;
 
   Member<IDBTransaction> transaction_;
   ReadyState ready_state_ = PENDING;
   bool request_aborted_ = false;  // May be aborted by transaction then receive
                                   // async onsuccess; ignore vs. assert.
   // Maintain the isolate so that all externally allocated memory can be
   // registered against it.
   v8::Isolate* isolate_;
 
  private:
   void SetResultCursor(IDBCursor*,
                        IDBKey*,
                        IDBKey* primary_key,
                        PassRefPtr<IDBValue>);
   void AckReceivedBlobs(const IDBValue*);
   void AckReceivedBlobs(const Vector<RefPtr<IDBValue>>&);
 
+  void ClearTransitBlobHandles() { transit_blob_handles_.clear(); }
+
   Member<IDBAny> source_;
   Member<IDBAny> result_;
   Member<DOMException> error_;
 
   bool has_pending_activity_ = true;
   HeapVector<Member<Event>> enqueued_events_;
 
   // Only used if the result type will be a cursor.
   IndexedDB::CursorType cursor_type_ = IndexedDB::kCursorKeyAndValue;
   WebIDBCursorDirection cursor_direction_ = kWebIDBCursorDirectionNext;
   // When a cursor is continued/advanced, |result_| is cleared and
   // |pendingCursor_| holds it.
   Member<IDBCursor> pending_cursor_;
   // New state is not applied to the cursor object until the event is
   // dispatched.
   Member<IDBKey> cursor_key_;
   Member<IDBKey> cursor_primary_key_;
   RefPtr<IDBValue> cursor_value_;
 
+  HashMap<String, RefPtr<BlobDataHandle>> transit_blob_handles_;
+
   bool did_fire_upgrade_needed_event_ = false;
   bool prevent_propagation_ = false;
   bool result_dirty_ = true;
 
   // Transactions should be aborted after event dispatch if an exception was
   // not caught. This is cleared before dispatch, set by a call to
   // UncaughtExceptionInEventHandler() during dispatch, and checked afterwards
   // to abort if necessary.
   bool did_throw_in_event_handler_ = false;
 
   // Pointer back to the WebIDBCallbacks that holds a persistent reference to
   // this object.
   WebIDBCallbacks* web_callbacks_ = nullptr;
 };
 
 }  // namespace blink
 
 #endif  // IDBRequest_h