Remove Create() methods which use MakeGarbageCollected<> in modules/webdatabase

As advised in [1], this CL removes unnecessary Foo::Create() factory functions
which return an instance created by MakeGarbageCollected<Foo> in
//third_party/blink/renderer/modules/webdatabase, then this CL makes
the callers use MakeGarbageCollected<Foo> instead of Foo::Create() factory
functions.

[1] https://groups.google.com/a/chromium.org/forum/#!msg/blink-dev/iJ1bawbxbWs/vEdfT5QtBgAJ

Bug: 939691
Change-Id: Ic675c3325b66468b4686f69e0f950cc8d99034b2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1556964Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Gyuyoung Kim <gyuyoung@igalia.com>
Cr-Commit-Position: refs/heads/master@{#648656}

third_party/blink/renderer/modules/modules_initializer.cc

@@ -234,7 +234,7 @@ void ModulesInitializer::InitInspectorAgentSession(
   session->Append(MakeGarbageCollected<InspectorAccessibilityAgent>(
       inspected_frames, dom_agent));
   if (allow_view_agents) {
-    session->Append(InspectorDatabaseAgent::Create(page));
+    session->Append(MakeGarbageCollected<InspectorDatabaseAgent>(page));
     session->Append(
         MakeGarbageCollected<InspectorCacheStorageAgent>(inspected_frames));
   }

third_party/blink/renderer/modules/webdatabase/change_version_wrapper.h

@@ -39,11 +39,6 @@ class SQLErrorData;
 
 class ChangeVersionWrapper final : public SQLTransactionWrapper {
  public:
-  static ChangeVersionWrapper* Create(const String& old_version,
-                                      const String& new_version) {
-    return MakeGarbageCollected<ChangeVersionWrapper>(old_version, new_version);
-  }
-
   ChangeVersionWrapper(const String& old_version, const String& new_version);
 
   bool PerformPreflight(SQLTransactionBackend*) override;

third_party/blink/renderer/modules/webdatabase/database.cc

@@ -346,12 +346,13 @@ SQLTransactionBackend* Database::RunTransaction(SQLTransaction* transaction,
     return nullptr;
 
   SQLTransactionWrapper* wrapper = nullptr;
-  if (data)
-    wrapper =
-        ChangeVersionWrapper::Create(data->OldVersion(), data->NewVersion());
+  if (data) {
+    wrapper = MakeGarbageCollected<ChangeVersionWrapper>(data->OldVersion(),
+                                                         data->NewVersion());
+  }
 
-  SQLTransactionBackend* transaction_backend =
-      SQLTransactionBackend::Create(this, transaction, wrapper, read_only);
+  auto* transaction_backend = MakeGarbageCollected<SQLTransactionBackend>(
+      this, transaction, wrapper, read_only);
   transaction_queue_.push_back(transaction_backend);
   if (!transaction_in_progress_)
     ScheduleTransaction();
@@ -806,7 +807,7 @@ void Database::PerformTransaction(
 static void CallTransactionErrorCallback(
     SQLTransaction::OnErrorCallback* callback,
     std::unique_ptr<SQLErrorData> error_data) {
-  callback->OnError(SQLError::Create(*error_data));
+  callback->OnError(MakeGarbageCollected<SQLError>(*error_data));
 }
 
 void Database::RunTransaction(

third_party/blink/renderer/modules/webdatabase/database_context.cc

@@ -145,7 +145,7 @@ DatabaseThread* DatabaseContext::GetDatabaseThread() {
     // Create the database thread on first request - but not if at least one
     // database was already opened, because in that case we already had a
     // database thread and terminated it and should not create another.
-    database_thread_ = DatabaseThread::Create();
+    database_thread_ = MakeGarbageCollected<DatabaseThread>();
     database_thread_->Start();
   }
 

third_party/blink/renderer/modules/webdatabase/database_thread.h

@@ -44,10 +44,6 @@ class SQLTransactionCoordinator;
 
 class DatabaseThread : public GarbageCollectedFinalized<DatabaseThread> {
  public:
-  static DatabaseThread* Create() {
-    return MakeGarbageCollected<DatabaseThread>();
-  }
-
   DatabaseThread();
   ~DatabaseThread();
   void Trace(blink::Visitor*);

third_party/blink/renderer/modules/webdatabase/inspector_database_agent.cc

@@ -82,11 +82,6 @@ class ExecuteSQLCallbackWrapper : public RefCounted<ExecuteSQLCallbackWrapper> {
 
 class StatementCallback final : public SQLStatement::OnSuccessCallback {
  public:
-  static StatementCallback* Create(
-      scoped_refptr<ExecuteSQLCallbackWrapper> request_callback) {
-    return MakeGarbageCollected<StatementCallback>(std::move(request_callback));
-  }
-
   explicit StatementCallback(
       scoped_refptr<ExecuteSQLCallbackWrapper> request_callback)
       : request_callback_(std::move(request_callback)) {}
@@ -130,12 +125,6 @@ class StatementCallback final : public SQLStatement::OnSuccessCallback {
 
 class StatementErrorCallback final : public SQLStatement::OnErrorCallback {
  public:
-  static StatementErrorCallback* Create(
-      scoped_refptr<ExecuteSQLCallbackWrapper> request_callback) {
-    return MakeGarbageCollected<StatementErrorCallback>(
-        std::move(request_callback));
-  }
-
   explicit StatementErrorCallback(
       scoped_refptr<ExecuteSQLCallbackWrapper> request_callback)
       : request_callback_(std::move(request_callback)) {}
@@ -152,13 +141,6 @@ class StatementErrorCallback final : public SQLStatement::OnErrorCallback {
 
 class TransactionCallback final : public SQLTransaction::OnProcessCallback {
  public:
-  static TransactionCallback* Create(
-      const String& sql_statement,
-      scoped_refptr<ExecuteSQLCallbackWrapper> request_callback) {
-    return MakeGarbageCollected<TransactionCallback>(
-        sql_statement, std::move(request_callback));
-  }
-
   explicit TransactionCallback(
       const String& sql_statement,
       scoped_refptr<ExecuteSQLCallbackWrapper> request_callback)
@@ -168,10 +150,11 @@ class TransactionCallback final : public SQLTransaction::OnProcessCallback {
 
   bool OnProcess(SQLTransaction* transaction) override {
     Vector<SQLValue> sql_values;
-    transaction->ExecuteSQL(sql_statement_, sql_values,
-                            StatementCallback::Create(request_callback_),
-                            StatementErrorCallback::Create(request_callback_),
-                            IGNORE_EXCEPTION_FOR_TESTING);
+    transaction->ExecuteSQL(
+        sql_statement_, sql_values,
+        MakeGarbageCollected<StatementCallback>(request_callback_),
+        MakeGarbageCollected<StatementErrorCallback>(request_callback_),
+        IGNORE_EXCEPTION_FOR_TESTING);
     return true;
   }
 
@@ -220,8 +203,8 @@ void InspectorDatabaseAgent::DidOpenDatabase(blink::Database* database,
     return;
   }
 
-  InspectorDatabaseResource* resource =
-      InspectorDatabaseResource::Create(database, domain, name, version);
+  auto* resource = MakeGarbageCollected<InspectorDatabaseResource>(
+      database, domain, name, version);
   resources_.Set(resource->Id(), resource);
   // Resources are only bound while visible.
   DCHECK(enabled_.Get());
@@ -313,7 +296,7 @@ void InspectorDatabaseAgent::executeSQL(
 
   scoped_refptr<ExecuteSQLCallbackWrapper> wrapper =
       ExecuteSQLCallbackWrapper::Create(std::move(request_callback));
-  TransactionCallback* callback = TransactionCallback::Create(query, wrapper);
+  auto* callback = MakeGarbageCollected<TransactionCallback>(query, wrapper);
   TransactionErrorCallback* error_callback =
       TransactionErrorCallback::Create(wrapper);
   SQLTransaction::OnSuccessCallback* success_callback = nullptr;

third_party/blink/renderer/modules/webdatabase/inspector_database_agent.h

@@ -46,10 +46,6 @@ class Page;
 class MODULES_EXPORT InspectorDatabaseAgent final
     : public InspectorBaseAgent<protocol::Database::Metainfo> {
  public:
-  static InspectorDatabaseAgent* Create(Page* page) {
-    return MakeGarbageCollected<InspectorDatabaseAgent>(page);
-  }
-
   explicit InspectorDatabaseAgent(Page*);
   ~InspectorDatabaseAgent() override;
   void Trace(blink::Visitor*) override;

third_party/blink/renderer/modules/webdatabase/inspector_database_resource.cc

@@ -36,15 +36,6 @@ namespace blink {
 
 static int g_next_unused_id = 1;
 
-InspectorDatabaseResource* InspectorDatabaseResource::Create(
-    Database* database,
-    const String& domain,
-    const String& name,
-    const String& version) {
-  return MakeGarbageCollected<InspectorDatabaseResource>(database, domain, name,
-                                                         version);
-}
-
 InspectorDatabaseResource::InspectorDatabaseResource(Database* database,
                                                      const String& domain,
                                                      const String& name,

third_party/blink/renderer/modules/webdatabase/inspector_database_resource.h

@@ -42,10 +42,6 @@ class Database;
 class InspectorDatabaseResource
     : public GarbageCollectedFinalized<InspectorDatabaseResource> {
  public:
-  static InspectorDatabaseResource* Create(Database*,
-                                           const String& domain,
-                                           const String& name,
-                                           const String& version);
   InspectorDatabaseResource(Database*,
                             const String& domain,
                             const String& name,

third_party/blink/renderer/modules/webdatabase/sql_error.h

@@ -68,10 +68,6 @@ class SQLError final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static SQLError* Create(const SQLErrorData& data) {
-    return MakeGarbageCollected<SQLError>(data);
-  }
-
   explicit SQLError(const SQLErrorData& data) : data_(data) {}
 
   unsigned code() const { return data_.Code(); }

third_party/blink/renderer/modules/webdatabase/sql_result_set.cc

@@ -34,7 +34,7 @@
 namespace blink {
 
 SQLResultSet::SQLResultSet()
-    : rows_(SQLResultSetRowList::Create()),
+    : rows_(MakeGarbageCollected<SQLResultSetRowList>()),
       insert_id_(0),
       rows_affected_(0),
       insert_id_set_(false),

third_party/blink/renderer/modules/webdatabase/sql_result_set.h

@@ -41,8 +41,6 @@ class SQLResultSet final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static SQLResultSet* Create() { return MakeGarbageCollected<SQLResultSet>(); }
-
   SQLResultSet();
 
   void Trace(blink::Visitor*) override;

third_party/blink/renderer/modules/webdatabase/sql_result_set_row_list.h

@@ -43,10 +43,6 @@ class SQLResultSetRowList final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static SQLResultSetRowList* Create() {
-    return MakeGarbageCollected<SQLResultSetRowList>();
-  }
-
   SQLResultSetRowList() = default;
 
   const Vector<String>& ColumnNames() const { return columns_; }

third_party/blink/renderer/modules/webdatabase/sql_statement.cc

@@ -83,12 +83,6 @@ bool SQLStatement::OnErrorV8Impl::OnError(SQLTransaction* transaction,
   return return_value;
 }
 
-SQLStatement* SQLStatement::Create(Database* database,
-                                   OnSuccessCallback* callback,
-                                   OnErrorCallback* error_callback) {
-  return MakeGarbageCollected<SQLStatement>(database, callback, error_callback);
-}
-
 SQLStatement::SQLStatement(Database* database,
                            OnSuccessCallback* callback,
                            OnErrorCallback* error_callback)
@@ -136,8 +130,8 @@ bool SQLStatement::PerformCallback(SQLTransaction* transaction) {
   // error, because then we need to jump to the transaction error callback.
   if (error) {
     if (error_callback) {
-      callback_error =
-          error_callback->OnError(transaction, SQLError::Create(*error));
+      callback_error = error_callback->OnError(
+          transaction, MakeGarbageCollected<SQLError>(*error));
     }
   } else if (callback) {
     callback_error =

third_party/blink/renderer/modules/webdatabase/sql_statement_backend.cc

@@ -82,15 +82,6 @@
 
 namespace blink {
 
-SQLStatementBackend* SQLStatementBackend::Create(
-    SQLStatement* frontend,
-    const String& statement,
-    const Vector<SQLValue>& arguments,
-    int permissions) {
-  return MakeGarbageCollected<SQLStatementBackend>(frontend, statement,
-                                                   arguments, permissions);
-}
-
 SQLStatementBackend::SQLStatementBackend(SQLStatement* frontend,
                                          const String& statement,
                                          const Vector<SQLValue>& arguments,
@@ -100,7 +91,7 @@ SQLStatementBackend::SQLStatementBackend(SQLStatement* frontend,
       arguments_(arguments),
       has_callback_(frontend_->HasCallback()),
       has_error_callback_(frontend_->HasErrorCallback()),
-      result_set_(SQLResultSet::Create()),
+      result_set_(MakeGarbageCollected<SQLResultSet>()),
       permissions_(permissions) {
   DCHECK(IsMainThread());
 

third_party/blink/renderer/modules/webdatabase/sql_statement_backend.h

@@ -45,11 +45,6 @@ class SQLStatement;
 class SQLStatementBackend final
     : public GarbageCollectedFinalized<SQLStatementBackend> {
  public:
-  static SQLStatementBackend* Create(SQLStatement*,
-                                     const String& sql_statement,
-                                     const Vector<SQLValue>& arguments,
-                                     int permissions);
-
   SQLStatementBackend(SQLStatement*,
                       const String& statement,
                       const Vector<SQLValue>& arguments,

third_party/blink/renderer/modules/webdatabase/sql_transaction.cc

@@ -223,7 +223,8 @@ SQLTransactionState SQLTransaction::DeliverTransactionErrorCallback() {
           std::make_unique<SQLErrorData>(*backend_->TransactionError());
     }
     DCHECK(transaction_error_);
-    error_callback->OnError(SQLError::Create(*transaction_error_));
+    error_callback->OnError(
+        MakeGarbageCollected<SQLError>(*transaction_error_));
 
     transaction_error_ = nullptr;
   }
@@ -328,8 +329,8 @@ void SQLTransaction::ExecuteSQL(const String& sql_statement,
   else if (read_only_)
     permissions |= DatabaseAuthorizer::kReadOnlyMask;
 
-  SQLStatement* statement =
-      SQLStatement::Create(database_.Get(), callback, callback_error);
+  auto* statement = MakeGarbageCollected<SQLStatement>(
+      database_.Get(), callback, callback_error);
   backend_->ExecuteSQL(statement, sql_statement, arguments, permissions);
 }
 

third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.cc

@@ -366,15 +366,6 @@
 
 namespace blink {
 
-SQLTransactionBackend* SQLTransactionBackend::Create(
-    Database* db,
-    SQLTransaction* frontend,
-    SQLTransactionWrapper* wrapper,
-    bool read_only) {
-  return MakeGarbageCollected<SQLTransactionBackend>(db, frontend, wrapper,
-                                                     read_only);
-}
-
 SQLTransactionBackend::SQLTransactionBackend(Database* db,
                                              SQLTransaction* frontend,
                                              SQLTransactionWrapper* wrapper,
@@ -563,8 +554,8 @@ void SQLTransactionBackend::ExecuteSQL(SQLStatement* statement,
                                        const Vector<SQLValue>& arguments,
                                        int permissions) {
   DCHECK(IsMainThread());
-  EnqueueStatementBackend(SQLStatementBackend::Create(statement, sql_statement,
-                                                      arguments, permissions));
+  EnqueueStatementBackend(MakeGarbageCollected<SQLStatementBackend>(
+      statement, sql_statement, arguments, permissions));
 }
 
 void SQLTransactionBackend::NotifyDatabaseThreadIsShuttingDown() {

third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.h

@@ -62,11 +62,6 @@ class SQLTransactionBackend final
     : public GarbageCollectedFinalized<SQLTransactionBackend>,
       public SQLTransactionStateMachine<SQLTransactionBackend> {
  public:
-  static SQLTransactionBackend* Create(Database*,
-                                       SQLTransaction*,
-                                       SQLTransactionWrapper*,
-                                       bool read_only);
-
   SQLTransactionBackend(Database*,
                         SQLTransaction*,
                         SQLTransactionWrapper*,