Clean up unnecessary Create() factory functions in modules/webdatabase

As advised in [1], this CL removes unnecessary Foo::Create() in
//third_party/blink/renderer/modules/webdatabase and make their constructors
public, then make the callers use std::make_unique<Foo> instead
of their Create() factory functions.

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

Bug: 939691
Change-Id: Ieb05b6cc4a8e4f6a0938c0732bd6ec68a100fd69
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1524395
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Gyuyoung Kim <gyuyoung@igalia.com>
Cr-Commit-Position: refs/heads/master@{#641165}
diff --git a/third_party/blink/renderer/modules/webdatabase/change_version_wrapper.cc b/third_party/blink/renderer/modules/webdatabase/change_version_wrapper.cc
index 44d8ee42..9898834 100644
--- a/third_party/blink/renderer/modules/webdatabase/change_version_wrapper.cc
+++ b/third_party/blink/renderer/modules/webdatabase/change_version_wrapper.cc
@@ -55,9 +55,10 @@
   }
 
   if (actual_version != old_version_) {
-    sql_error_ = SQLErrorData::Create(SQLError::kVersionErr,
-                                      "current version of the database and "
-                                      "`oldVersion` argument do not match");
+    sql_error_ =
+        std::make_unique<SQLErrorData>(SQLError::kVersionErr,
+                                       "current version of the database and "
+                                       "`oldVersion` argument do not match");
     return false;
   }
 
diff --git a/third_party/blink/renderer/modules/webdatabase/database.cc b/third_party/blink/renderer/modules/webdatabase/database.cc
index b5a1235..a0897dc 100644
--- a/third_party/blink/renderer/modules/webdatabase/database.cc
+++ b/third_party/blink/renderer/modules/webdatabase/database.cc
@@ -288,7 +288,7 @@
 
   DatabaseTracker::Tracker().PrepareToOpenDatabase(this);
   bool success = false;
-  std::unique_ptr<DatabaseOpenTask> task = DatabaseOpenTask::Create(
+  auto task = std::make_unique<DatabaseOpenTask>(
       this, set_version_in_new_database, &event, error, error_message, success);
   GetDatabaseContext()->GetDatabaseThread()->ScheduleTask(std::move(task));
   event.Wait();
@@ -377,8 +377,7 @@
     transaction = transaction_queue_.TakeFirst();
 
   if (transaction && GetDatabaseContext()->DatabaseThreadAvailable()) {
-    std::unique_ptr<DatabaseTransactionTask> task =
-        DatabaseTransactionTask::Create(transaction);
+    auto task = std::make_unique<DatabaseTransactionTask>(transaction);
     STORAGE_DVLOG(1) << "Scheduling DatabaseTransactionTask " << task.get()
                      << " for transaction " << task->Transaction();
     transaction_in_progress_ = true;
@@ -392,8 +391,7 @@
   if (!GetDatabaseContext()->DatabaseThreadAvailable())
     return;
 
-  std::unique_ptr<DatabaseTransactionTask> task =
-      DatabaseTransactionTask::Create(transaction);
+  auto task = std::make_unique<DatabaseTransactionTask>(transaction);
   STORAGE_DVLOG(1) << "Scheduling DatabaseTransactionTask " << task.get()
                    << " for the transaction step";
   GetDatabaseContext()->GetDatabaseThread()->ScheduleTask(std::move(task));
@@ -776,7 +774,7 @@
   if (GetDatabaseContext()->DatabaseThreadAvailable() && Opened()) {
     LogErrorMessage("forcibly closing database");
     GetDatabaseContext()->GetDatabaseThread()->ScheduleTask(
-        DatabaseCloseTask::Create(this, nullptr));
+        std::make_unique<DatabaseCloseTask>(this, nullptr));
   }
 }
 
@@ -851,8 +849,8 @@
     DCHECK_EQ(transaction_error_callback, original_error_callback);
 #endif
     if (transaction_error_callback) {
-      std::unique_ptr<SQLErrorData> error = SQLErrorData::Create(
-          SQLError::kUnknownErr, "database has been closed");
+      auto error = std::make_unique<SQLErrorData>(SQLError::kUnknownErr,
+                                                  "database has been closed");
       GetDatabaseTaskRunner()->PostTask(
           FROM_HERE, WTF::Bind(&CallTransactionErrorCallback,
                                WrapPersistent(transaction_error_callback),
@@ -908,8 +906,7 @@
   if (!GetDatabaseContext()->DatabaseThreadAvailable())
     return result;
 
-  std::unique_ptr<DatabaseTableNamesTask> task =
-      DatabaseTableNamesTask::Create(this, &event, result);
+  auto task = std::make_unique<DatabaseTableNamesTask>(this, &event, result);
   GetDatabaseContext()->GetDatabaseThread()->ScheduleTask(std::move(task));
   event.Wait();
 
diff --git a/third_party/blink/renderer/modules/webdatabase/database_task.h b/third_party/blink/renderer/modules/webdatabase/database_task.h
index 6339445..31db2441 100644
--- a/third_party/blink/renderer/modules/webdatabase/database_task.h
+++ b/third_party/blink/renderer/modules/webdatabase/database_task.h
@@ -75,19 +75,6 @@
 
 class Database::DatabaseOpenTask final : public DatabaseTask {
  public:
-  static std::unique_ptr<DatabaseOpenTask> Create(
-      Database* db,
-      bool set_version_in_new_database,
-      base::WaitableEvent* complete_event,
-      DatabaseError& error,
-      String& error_message,
-      bool& success) {
-    return base::WrapUnique(
-        new DatabaseOpenTask(db, set_version_in_new_database, complete_event,
-                             error, error_message, success));
-  }
-
- private:
   DatabaseOpenTask(Database*,
                    bool set_version_in_new_database,
                    base::WaitableEvent*,
@@ -95,6 +82,7 @@
                    String& error_message,
                    bool& success);
 
+ private:
   void DoPerformTask() override;
 #if DCHECK_IS_ON()
   const char* DebugTaskName() const override;
@@ -108,15 +96,9 @@
 
 class Database::DatabaseCloseTask final : public DatabaseTask {
  public:
-  static std::unique_ptr<DatabaseCloseTask> Create(
-      Database* db,
-      base::WaitableEvent* synchronizer) {
-    return base::WrapUnique(new DatabaseCloseTask(db, synchronizer));
-  }
-
- private:
   DatabaseCloseTask(Database*, base::WaitableEvent*);
 
+ private:
   void DoPerformTask() override;
 #if DCHECK_IS_ON()
   const char* DebugTaskName() const override;
@@ -125,19 +107,13 @@
 
 class Database::DatabaseTransactionTask final : public DatabaseTask {
  public:
-  ~DatabaseTransactionTask() override;
-
   // Transaction task is never synchronous, so no 'synchronizer' parameter.
-  static std::unique_ptr<DatabaseTransactionTask> Create(
-      SQLTransactionBackend* transaction) {
-    return base::WrapUnique(new DatabaseTransactionTask(transaction));
-  }
+  explicit DatabaseTransactionTask(SQLTransactionBackend*);
+  ~DatabaseTransactionTask() override;
 
   SQLTransactionBackend* Transaction() const { return transaction_.Get(); }
 
  private:
-  explicit DatabaseTransactionTask(SQLTransactionBackend*);
-
   void DoPerformTask() override;
   void TaskCancelled() override;
 #if DCHECK_IS_ON()
@@ -149,19 +125,11 @@
 
 class Database::DatabaseTableNamesTask final : public DatabaseTask {
  public:
-  static std::unique_ptr<DatabaseTableNamesTask> Create(
-      Database* db,
-      base::WaitableEvent* synchronizer,
-      Vector<String>& names) {
-    return base::WrapUnique(
-        new DatabaseTableNamesTask(db, synchronizer, names));
-  }
-
- private:
   DatabaseTableNamesTask(Database*,
                          base::WaitableEvent*,
                          Vector<String>& names);
 
+ private:
   void DoPerformTask() override;
 #if DCHECK_IS_ON()
   const char* DebugTaskName() const override;
diff --git a/third_party/blink/renderer/modules/webdatabase/sql_error.h b/third_party/blink/renderer/modules/webdatabase/sql_error.h
index afcd120..0cf5de3 100644
--- a/third_party/blink/renderer/modules/webdatabase/sql_error.h
+++ b/third_party/blink/renderer/modules/webdatabase/sql_error.h
@@ -42,21 +42,16 @@
 
  public:
   static std::unique_ptr<SQLErrorData> Create(unsigned code,
-                                              const String& message) {
-    return base::WrapUnique(new SQLErrorData(code, message));
-  }
-
-  static std::unique_ptr<SQLErrorData> Create(unsigned code,
                                               const char* message,
                                               int sqlite_code,
                                               const char* sqlite_message) {
-    return Create(code, String::Format("%s (%d %s)", message, sqlite_code,
-                                       sqlite_message));
+    return std::make_unique<SQLErrorData>(
+        code,
+        String::Format("%s (%d %s)", message, sqlite_code, sqlite_message));
   }
 
-  static std::unique_ptr<SQLErrorData> Create(const SQLErrorData& data) {
-    return Create(data.Code(), data.Message());
-  }
+  SQLErrorData(unsigned code, const String& message)
+      : code_(code), message_(message.IsolatedCopy()) {}
 
   SQLErrorData(const SQLErrorData& data)
       : code_(data.code_), message_(data.message_.IsolatedCopy()) {}
@@ -65,9 +60,6 @@
   String Message() const { return message_.IsolatedCopy(); }
 
  private:
-  SQLErrorData(unsigned code, const String& message)
-      : code_(code), message_(message.IsolatedCopy()) {}
-
   unsigned code_;
   String message_;
 };
diff --git a/third_party/blink/renderer/modules/webdatabase/sql_statement_backend.cc b/third_party/blink/renderer/modules/webdatabase/sql_statement_backend.cc
index e331be9..2e9d147 100644
--- a/third_party/blink/renderer/modules/webdatabase/sql_statement_backend.cc
+++ b/third_party/blink/renderer/modules/webdatabase/sql_statement_backend.cc
@@ -166,7 +166,7 @@
   if (statement.BindParameterCount() != arguments_.size()) {
     STORAGE_DVLOG(1)
         << "Bind parameter count doesn't match number of question marks";
-    error_ = SQLErrorData::Create(
+    error_ = std::make_unique<SQLErrorData>(
         SQLError::kSyntaxErr,
         "number of '?'s in statement string does not match argument count");
     return false;
@@ -249,7 +249,7 @@
 void SQLStatementBackend::SetVersionMismatchedError(Database* database) {
   DCHECK(!error_);
   DCHECK(!result_set_->IsValid());
-  error_ = SQLErrorData::Create(
+  error_ = std::make_unique<SQLErrorData>(
       SQLError::kVersionErr,
       "current version of the database and `oldVersion` argument do not match");
 }
@@ -257,10 +257,11 @@
 void SQLStatementBackend::SetFailureDueToQuota(Database* database) {
   DCHECK(!error_);
   DCHECK(!result_set_->IsValid());
-  error_ = SQLErrorData::Create(SQLError::kQuotaErr,
-                                "there was not enough remaining storage "
-                                "space, or the storage quota was reached and "
-                                "the user declined to allow more space");
+  error_ = std::make_unique<SQLErrorData>(
+      SQLError::kQuotaErr,
+      "there was not enough remaining storage "
+      "space, or the storage quota was reached and "
+      "the user declined to allow more space");
 }
 
 void SQLStatementBackend::ClearFailureDueToQuota() {
diff --git a/third_party/blink/renderer/modules/webdatabase/sql_transaction.cc b/third_party/blink/renderer/modules/webdatabase/sql_transaction.cc
index a5ba0fe..5bccafb6 100644
--- a/third_party/blink/renderer/modules/webdatabase/sql_transaction.cc
+++ b/third_party/blink/renderer/modules/webdatabase/sql_transaction.cc
@@ -199,7 +199,7 @@
   // jump to the error callback.
   SQLTransactionState next_state = SQLTransactionState::kRunStatements;
   if (should_deliver_error_callback) {
-    transaction_error_ = SQLErrorData::Create(
+    transaction_error_ = std::make_unique<SQLErrorData>(
         SQLError::kUnknownErr,
         "the SQLTransactionCallback was null or threw an exception");
     next_state = SQLTransactionState::kDeliverTransactionErrorCallback;
@@ -219,7 +219,8 @@
     // a lock.
     if (!transaction_error_) {
       DCHECK(backend_->TransactionError());
-      transaction_error_ = SQLErrorData::Create(*backend_->TransactionError());
+      transaction_error_ =
+          std::make_unique<SQLErrorData>(*backend_->TransactionError());
     }
     DCHECK(transaction_error_);
     error_callback->OnError(SQLError::Create(*transaction_error_));
@@ -248,10 +249,10 @@
   execute_sql_allowed_ = false;
 
   if (result) {
-    transaction_error_ =
-        SQLErrorData::Create(SQLError::kUnknownErr,
-                             "the statement callback raised an exception or "
-                             "statement error callback did not return false");
+    transaction_error_ = std::make_unique<SQLErrorData>(
+        SQLError::kUnknownErr,
+        "the statement callback raised an exception or "
+        "statement error callback did not return false");
     return NextStateForTransactionError();
   }
   return SQLTransactionState::kRunStatements;
diff --git a/third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.cc b/third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.cc
index fbd78bc..8ec97828 100644
--- a/third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.cc
+++ b/third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.cc
@@ -654,9 +654,10 @@
     sqlite_transaction_.reset();
     database_->EnableAuthorizer();
     if (wrapper_->SqlError()) {
-      transaction_error_ = SQLErrorData::Create(*wrapper_->SqlError());
+      transaction_error_ =
+          std::make_unique<SQLErrorData>(*wrapper_->SqlError());
     } else {
-      transaction_error_ = SQLErrorData::Create(
+      transaction_error_ = std::make_unique<SQLErrorData>(
           SQLError::kUnknownErr,
           "unknown error occurred during transaction preflight");
     }
@@ -772,9 +773,9 @@
 
   if (current_statement_backend_->SqlError()) {
     transaction_error_ =
-        SQLErrorData::Create(*current_statement_backend_->SqlError());
+        std::make_unique<SQLErrorData>(*current_statement_backend_->SqlError());
   } else {
-    transaction_error_ = SQLErrorData::Create(
+    transaction_error_ = std::make_unique<SQLErrorData>(
         SQLError::kDatabaseErr, "the statement failed to execute");
   }
   return NextStateForTransactionError();
@@ -787,9 +788,10 @@
   // they fail.
   if (wrapper_ && !wrapper_->PerformPostflight(this)) {
     if (wrapper_->SqlError()) {
-      transaction_error_ = SQLErrorData::Create(*wrapper_->SqlError());
+      transaction_error_ =
+          std::make_unique<SQLErrorData>(*wrapper_->SqlError());
     } else {
-      transaction_error_ = SQLErrorData::Create(
+      transaction_error_ = std::make_unique<SQLErrorData>(
           SQLError::kUnknownErr,
           "unknown error occurred during transaction postflight");
     }