Port messages sent by WebIDBFactoryImpl to Mojo.

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

 /*
  * 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 24 matching lines @@
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventQueue.h"
 #include "modules/IndexedDBNames.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValue.h"
+#include "modules/indexeddb/WebIDBCallbacksImpl.h"
 #include "platform/SharedBuffer.h"
 #include "public/platform/WebBlobInfo.h"
 #include <memory>
 
 using blink::WebIDBCursor;
 
 namespace blink {
 
 IDBRequest* IDBRequest::create(ScriptState* scriptState,
                                IDBAny* source,
@@ skipping 70 matching lines @@
 
 const String& IDBRequest::readyState() const {
   DCHECK(m_readyState == PENDING || m_readyState == DONE);
 
   if (m_readyState == PENDING)
     return IndexedDBNames::pending;
 
   return IndexedDBNames::done;
 }
 
+std::unique_ptr<WebIDBCallbacks> IDBRequest::createWebCallbacks() {
+  DCHECK(!m_webCallbacks);
+  std::unique_ptr<WebIDBCallbacks> callbacks =
+      WebIDBCallbacksImpl::create(this);
+  m_webCallbacks = callbacks.get();
+  return callbacks;
+}
+
+void IDBRequest::webCallbacksDestroyed() {
+  DCHECK(m_webCallbacks);
+  m_webCallbacks = nullptr;

[haraken, 2016/10/18 19:01:29]

Don't we need to call m_webCallbacks->detach()?

Just to confirm: Why do we need to call webCallbacksDestroyed() when the context
gets detached? I just want to confirm that contextDestroyed() is a right timing
to call webCallbacksDestroyed().

[Reilly Grant (use Gerrit), 2016/10/19 00:36:51]

m_webCallbacks->detach() just clears the callback object's pointer back to this
object. Since we know the callback object is being destroyed here there's no
reason to tell it to clear a pointer that's about to be cleared anyways.
We call IDBRequest::webCallbacksDestroyed() so that IDBRequest doesn't call
WebIDBCallbacks::detach() after the WebIDBCallbacks has been destroyed. The
detach is the important part because it prevents IDBRequest from getting calls
after the execution context been destroyed because existing code in IDBRequest
assumes that getExecutionContext() will always return non-NULL. The call to
webCallbacksDestroyed() exists to prevent a use after free in the other
direction since these two objects can be destroyed in either order.

Note that all of this mess can go away when IDBRequest owns the
mojo::Binding<Callbacks> that WebIDBCallbacksImpl currently does and calls
Binding::reset() in both contextDestroyed() and its pre-finalizer.

+}
+
 void IDBRequest::abort() {
   DCHECK(!m_requestAborted);
   if (m_contextStopped || !getExecutionContext())
     return;
   DCHECK(m_readyState == PENDING || m_readyState == DONE);
   if (m_readyState == DONE)
     return;
 
   EventQueue* eventQueue = getExecutionContext()->getEventQueue();
   for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
@@ skipping 245 matching lines @@
     }
   }
 
   m_enqueuedEvents.clear();
   if (m_source)
     m_source->contextWillBeDestroyed();
   if (m_result)
     m_result->contextWillBeDestroyed();
   if (m_pendingCursor)
     m_pendingCursor->contextWillBeDestroyed();
+  if (m_webCallbacks) {
+    m_webCallbacks->detach();
+    m_webCallbacks = nullptr;
+  }
 }
 
 const AtomicString& IDBRequest::interfaceName() const {
   return EventTargetNames::IDBRequest;
 }
 
 ExecutionContext* IDBRequest::getExecutionContext() const {
   return ActiveDOMObject::getExecutionContext();
 }
 
@@ skipping 132 matching lines @@
 }
 
 void IDBRequest::dequeueEvent(Event* event) {
   for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
     if (m_enqueuedEvents[i].get() == event)
       m_enqueuedEvents.remove(i);
   }
 }
 
 }  // namespace blink