v8binding: Enables wrapper-tracing in CallbackInterfaceBase.

Makes CallbackInterfaceBase and its subclasses use wrapper-tracing
to retain the underlying v8::Object.  Lets existing clients of
CallbackInterfaceBase, which don't support wrapper-tracing, use
V8PersistentCallbackInterface<T> instead.  The behavior and lifetime
shouldn't change.

Bug: 778580
Change-Id: If5db42a3b8cd5622de0576a920128a0b5ab0861f
Reviewed-on: https://chromium-review.googlesource.com/951163Reviewed-by: Hitoshi Yoshida <peria@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#541728}

third_party/WebKit/Source/bindings/core/v8/DictionaryHelperForCore.cpp

@@ -34,7 +34,6 @@
 #include "bindings/core/v8/V8MessagePort.h"
 #include "bindings/core/v8/V8TextTrack.h"
 #include "bindings/core/v8/V8Uint8Array.h"
-#include "bindings/core/v8/V8VoidCallback.h"
 #include "bindings/core/v8/V8Window.h"
 #include "core/html/track/TrackBase.h"
 #include "platform/wtf/MathExtras.h"

third_party/WebKit/Source/modules/filesystem/DirectoryReader.cpp

@@ -30,8 +30,6 @@
 
 #include "modules/filesystem/DirectoryReader.h"
 
-#include "bindings/modules/v8/V8EntriesCallback.h"
-#include "bindings/modules/v8/V8ErrorCallback.h"
 #include "core/fileapi/FileError.h"
 #include "modules/filesystem/Entry.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
@@ -40,7 +38,9 @@ namespace blink {
 
 namespace {
 
-void RunEntriesCallback(V8EntriesCallback* callback, EntryHeapVector* entries) {
+void RunEntriesCallback(
+    V8PersistentCallbackInterface<V8EntriesCallback>* callback,
+    EntryHeapVector* entries) {
   callback->InvokeAndReportException(nullptr, *entries);
 }
 
@@ -120,19 +120,21 @@ void DirectoryReader::readEntries(V8EntriesCallback* entries_callback,
     EntryHeapVector* entries = new EntryHeapVector(std::move(entries_));
     DOMFileSystem::ScheduleCallback(
         Filesystem()->GetExecutionContext(),
-        WTF::Bind(&RunEntriesCallback, WrapPersistent(entries_callback),
-                  WrapPersistent(entries)));
+        WTF::Bind(
+            &RunEntriesCallback,
+            WrapPersistent(ToV8PersistentCallbackInterface(entries_callback)),
+            WrapPersistent(entries)));
     return;
   }
 
-  entries_callback_ = entries_callback;
-  error_callback_ = error_callback;
+  entries_callback_ = ToV8PersistentCallbackInterface(entries_callback);
+  error_callback_ = ToV8PersistentCallbackInterface(error_callback);
 }
 
 void DirectoryReader::AddEntries(const EntryHeapVector& entries) {
   entries_.AppendVector(entries);
   error_callback_ = nullptr;
-  if (V8EntriesCallback* entries_callback = entries_callback_.Release()) {
+  if (auto* entries_callback = entries_callback_.Release()) {
     EntryHeapVector entries;
     entries.swap(entries_);
     entries_callback->InvokeAndReportException(nullptr, entries);
@@ -142,7 +144,7 @@ void DirectoryReader::AddEntries(const EntryHeapVector& entries) {
 void DirectoryReader::OnError(FileError::ErrorCode error) {
   error_ = error;
   entries_callback_ = nullptr;
-  if (V8ErrorCallback* error_callback = error_callback_.Release()) {
+  if (auto* error_callback = error_callback_.Release()) {
     error_callback->InvokeAndReportException(
         nullptr, FileError::CreateDOMException(error_));
   }

third_party/WebKit/Source/modules/filesystem/DirectoryReader.h

@@ -31,6 +31,8 @@
 #ifndef DirectoryReader_h
 #define DirectoryReader_h
 
+#include "bindings/modules/v8/V8EntriesCallback.h"
+#include "bindings/modules/v8/V8ErrorCallback.h"
 #include "modules/filesystem/DOMFileSystem.h"
 #include "modules/filesystem/DirectoryReaderBase.h"
 #include "platform/heap/Handle.h"
@@ -38,9 +40,6 @@
 
 namespace blink {
 
-class V8EntriesCallback;
-class V8ErrorCallback;
-
 class DirectoryReader : public DirectoryReaderBase {
   DEFINE_WRAPPERTYPEINFO();
 
@@ -73,8 +72,8 @@ class DirectoryReader : public DirectoryReaderBase {
   bool is_reading_;
   EntryHeapVector entries_;
   FileError::ErrorCode error_ = FileError::ErrorCode::kOK;
-  Member<V8EntriesCallback> entries_callback_;
-  Member<V8ErrorCallback> error_callback_;
+  Member<V8PersistentCallbackInterface<V8EntriesCallback>> entries_callback_;
+  Member<V8PersistentCallbackInterface<V8ErrorCallback>> error_callback_;
 };
 
 }  // namespace blink

third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.cpp

@@ -33,13 +33,6 @@
 #include <memory>
 
 #include "base/memory/ptr_util.h"
-#include "bindings/core/v8/V8VoidCallback.h"
-#include "bindings/modules/v8/V8EntryCallback.h"
-#include "bindings/modules/v8/V8ErrorCallback.h"
-#include "bindings/modules/v8/V8FileCallback.h"
-#include "bindings/modules/v8/V8FileSystemCallback.h"
-#include "bindings/modules/v8/V8FileWriterCallback.h"
-#include "bindings/modules/v8/V8MetadataCallback.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileError.h"
@@ -131,7 +124,7 @@ void ScriptErrorCallback::Invoke(FileError::ErrorCode error) {
 };
 
 ScriptErrorCallback::ScriptErrorCallback(V8ErrorCallback* callback)
-    : callback_(callback) {}
+    : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
 // EntryCallbacks -------------------------------------------------------------
 

third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.h

@@ -33,6 +33,13 @@
 
 #include <memory>
 
+#include "bindings/core/v8/V8VoidCallback.h"
+#include "bindings/modules/v8/V8EntryCallback.h"
+#include "bindings/modules/v8/V8ErrorCallback.h"
+#include "bindings/modules/v8/V8FileCallback.h"
+#include "bindings/modules/v8/V8FileSystemCallback.h"
+#include "bindings/modules/v8/V8FileWriterCallback.h"
+#include "bindings/modules/v8/V8MetadataCallback.h"
 #include "core/fileapi/FileError.h"
 #include "modules/filesystem/EntryHeapVector.h"
 #include "platform/AsyncFileSystemCallbacks.h"
@@ -52,13 +59,6 @@ class File;
 class FileMetadata;
 class FileWriterBase;
 class Metadata;
-class V8EntryCallback;
-class V8ErrorCallback;
-class V8FileCallback;
-class V8FileSystemCallback;
-class V8FileWriterCallback;
-class V8MetadataCallback;
-class V8VoidCallback;
 
 // Passed to DOMFileSystem implementations that may report errors. Subclasses
 // may capture the error for throwing on return to script (for synchronous APIs)
@@ -114,7 +114,7 @@ class ScriptErrorCallback final : public ErrorCallbackBase {
 
  private:
   explicit ScriptErrorCallback(V8ErrorCallback*);
-  Member<V8ErrorCallback> callback_;
+  Member<V8PersistentCallbackInterface<V8ErrorCallback>> callback_;
 };
 
 class EntryCallbacks final : public FileSystemCallbacksBase {
@@ -139,9 +139,10 @@ class EntryCallbacks final : public FileSystemCallbacksBase {
     void OnSuccess(Entry*) override;
 
    private:
-    OnDidGetEntryV8Impl(V8EntryCallback* callback) : callback_(callback) {}
+    OnDidGetEntryV8Impl(V8EntryCallback* callback)
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8EntryCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8EntryCallback>> callback_;
   };
 
   static std::unique_ptr<AsyncFileSystemCallbacks> Create(
@@ -222,9 +223,9 @@ class FileSystemCallbacks final : public FileSystemCallbacksBase {
 
    private:
     OnDidOpenFileSystemV8Impl(V8FileSystemCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8FileSystemCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8FileSystemCallback>> callback_;
   };
 
   static std::unique_ptr<AsyncFileSystemCallbacks> Create(
@@ -286,9 +287,9 @@ class MetadataCallbacks final : public FileSystemCallbacksBase {
 
    private:
     OnDidReadMetadataV8Impl(V8MetadataCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8MetadataCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8MetadataCallback>> callback_;
   };
 
   static std::unique_ptr<AsyncFileSystemCallbacks> Create(
@@ -329,9 +330,9 @@ class FileWriterCallbacks final : public FileSystemCallbacksBase {
 
    private:
     OnDidCreateFileWriterV8Impl(V8FileWriterCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8FileWriterCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8FileWriterCallback>> callback_;
   };
 
   static std::unique_ptr<AsyncFileSystemCallbacks> Create(
@@ -374,9 +375,9 @@ class SnapshotFileCallback final : public FileSystemCallbacksBase {
 
    private:
     OnDidCreateSnapshotFileV8Impl(V8FileCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8FileCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8FileCallback>> callback_;
   };
 
   static std::unique_ptr<AsyncFileSystemCallbacks> Create(
@@ -423,9 +424,10 @@ class VoidCallbacks final : public FileSystemCallbacksBase {
     void OnSuccess(ExecutionContext* dummy_arg_for_sync_helper) override;
 
    private:
-    OnDidSucceedV8Impl(V8VoidCallback* callback) : callback_(callback) {}
+    OnDidSucceedV8Impl(V8VoidCallback* callback)
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8VoidCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8VoidCallback>> callback_;
   };
 
   static std::unique_ptr<AsyncFileSystemCallbacks> Create(OnDidSucceedCallback*,

third_party/WebKit/Source/modules/webdatabase/SQLStatement.h

@@ -28,6 +28,8 @@
 #ifndef SQLStatement_h
 #define SQLStatement_h
 
+#include "bindings/modules/v8/V8SQLStatementCallback.h"
+#include "bindings/modules/v8/V8SQLStatementErrorCallback.h"
 #include "modules/webdatabase/SQLResultSet.h"
 #include "modules/webdatabase/sqlite/SQLValue.h"
 #include "platform/wtf/Forward.h"
@@ -39,8 +41,6 @@ class Database;
 class SQLError;
 class SQLStatementBackend;
 class SQLTransaction;
-class V8SQLStatementCallback;
-class V8SQLStatementErrorCallback;
 
 class SQLStatement final : public GarbageCollected<SQLStatement> {
  public:
@@ -65,9 +65,9 @@ class SQLStatement final : public GarbageCollected<SQLStatement> {
 
    private:
     explicit OnSuccessV8Impl(V8SQLStatementCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8SQLStatementCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8SQLStatementCallback>> callback_;
   };
 
   class OnErrorCallback : public GarbageCollectedFinalized<OnErrorCallback> {
@@ -90,9 +90,10 @@ class SQLStatement final : public GarbageCollected<SQLStatement> {
 
    private:
     explicit OnErrorV8Impl(V8SQLStatementErrorCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8SQLStatementErrorCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8SQLStatementErrorCallback>>
+        callback_;
   };
 
   static SQLStatement* Create(Database*, OnSuccessCallback*, OnErrorCallback*);

third_party/WebKit/Source/modules/webdatabase/SQLTransaction.cpp

@@ -29,9 +29,6 @@
 #include "modules/webdatabase/SQLTransaction.h"
 
 #include "bindings/core/v8/ExceptionState.h"
-#include "bindings/core/v8/V8VoidCallback.h"
-#include "bindings/modules/v8/V8SQLTransactionCallback.h"
-#include "bindings/modules/v8/V8SQLTransactionErrorCallback.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/probe/CoreProbes.h"
 #include "modules/webdatabase/Database.h"

third_party/WebKit/Source/modules/webdatabase/SQLTransaction.h

@@ -30,7 +30,11 @@
 #define SQLTransaction_h
 
 #include <memory>
+
+#include "bindings/core/v8/V8VoidCallback.h"
 #include "bindings/modules/v8/V8BindingForModules.h"
+#include "bindings/modules/v8/V8SQLTransactionCallback.h"
+#include "bindings/modules/v8/V8SQLTransactionErrorCallback.h"
 #include "modules/webdatabase/SQLStatement.h"
 #include "modules/webdatabase/SQLTransactionStateMachine.h"
 #include "platform/bindings/ScriptWrappable.h"
@@ -45,9 +49,6 @@ class SQLErrorData;
 class SQLTransactionBackend;
 class SQLValue;
 class ScriptValue;
-class V8SQLTransactionCallback;
-class V8SQLTransactionErrorCallback;
-class V8VoidCallback;
 
 class SQLTransaction final : public ScriptWrappable,
                              public SQLTransactionStateMachine<SQLTransaction> {
@@ -75,9 +76,9 @@ class SQLTransaction final : public ScriptWrappable,
 
    private:
     explicit OnProcessV8Impl(V8SQLTransactionCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8SQLTransactionCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8SQLTransactionCallback>> callback_;
   };
 
   class OnSuccessCallback
@@ -100,9 +101,10 @@ class SQLTransaction final : public ScriptWrappable,
     void OnSuccess() override;
 
    private:
-    explicit OnSuccessV8Impl(V8VoidCallback* callback) : callback_(callback) {}
+    explicit OnSuccessV8Impl(V8VoidCallback* callback)
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8VoidCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8VoidCallback>> callback_;
   };
 
   class OnErrorCallback : public GarbageCollectedFinalized<OnErrorCallback> {
@@ -125,9 +127,10 @@ class SQLTransaction final : public ScriptWrappable,
 
    private:
     explicit OnErrorV8Impl(V8SQLTransactionErrorCallback* callback)
-        : callback_(callback) {}
+        : callback_(ToV8PersistentCallbackInterface(callback)) {}
 
-    Member<V8SQLTransactionErrorCallback> callback_;
+    Member<V8PersistentCallbackInterface<V8SQLTransactionErrorCallback>>
+        callback_;
   };
 
   static SQLTransaction* Create(Database*,

third_party/WebKit/Source/platform/bindings/CallbackInterfaceBase.cpp

@@ -21,6 +21,11 @@ CallbackInterfaceBase::CallbackInterfaceBase(
   incumbent_script_state_ = ScriptState::From(isolate->GetIncumbentContext());
 }
 
+void CallbackInterfaceBase::TraceWrappers(
+    const ScriptWrappableVisitor* visitor) const {
+  visitor->TraceWrappers(callback_object_);
+}
+
 V8PersistentCallbackInterfaceBase::V8PersistentCallbackInterfaceBase(
     CallbackInterfaceBase* callback_interface)
     : callback_interface_(callback_interface) {

third_party/WebKit/Source/platform/bindings/CallbackInterfaceBase.h

@@ -5,10 +5,10 @@
 #ifndef CallbackInterfaceBase_h
 #define CallbackInterfaceBase_h
 
-#include "platform/bindings/ScopedPersistent.h"
 #include "platform/bindings/ScriptState.h"
+#include "platform/bindings/TraceWrapperBase.h"
+#include "platform/bindings/TraceWrapperV8Reference.h"
 #include "platform/heap/Handle.h"
-#include "v8/include/v8.h"
 
 namespace blink {
 
@@ -23,7 +23,8 @@ class V8PersistentCallbackInterfaceBase;
 // As the signatures of callback interface's operations vary, this class does
 // not implement any operation. Subclasses will implement it.
 class PLATFORM_EXPORT CallbackInterfaceBase
-    : public GarbageCollectedFinalized<CallbackInterfaceBase> {
+    : public GarbageCollectedFinalized<CallbackInterfaceBase>,
+      public TraceWrapperBase {
  public:
   // Whether the callback interface is a "single operation callback interface"
   // or not.
@@ -36,6 +37,7 @@ class PLATFORM_EXPORT CallbackInterfaceBase
   virtual ~CallbackInterfaceBase() = default;
 
   virtual void Trace(blink::Visitor*) {}
+  void TraceWrappers(const ScriptWrappableVisitor*) const override;
 
   v8::Isolate* GetIsolate() {
     return callback_relevant_script_state_->GetIsolate();
@@ -58,8 +60,7 @@ class PLATFORM_EXPORT CallbackInterfaceBase
 
  private:
   // The "callback interface type" value.
-  // TODO(yukishiino): Replace ScopedPersistent with TraceWrapperMember.
-  ScopedPersistent<v8::Object> callback_object_;
+  TraceWrapperV8Reference<v8::Object> callback_object_;
   bool is_callback_object_callable_ = false;
   // The associated Realm of the callback interface type value. Note that the
   // callback interface type value can be different from the function object
@@ -87,6 +88,8 @@ class PLATFORM_EXPORT V8PersistentCallbackInterfaceBase
 
   virtual void Trace(blink::Visitor*);
 
+  v8::Isolate* GetIsolate() { return callback_interface_->GetIsolate(); }
+
  protected:
   explicit V8PersistentCallbackInterfaceBase(CallbackInterfaceBase*);