BASELINE: Update Chromium to 67.0.3396.47

Change-Id: Idcb1341782e417561a2473eeecc82642dafda5b7
Reviewed-by: Michal Klocek <michal.klocek@qt.io>

5 files changed, 33 insertions, 34 deletions

diff --git a/chromium/sql/connection.h b/chromium/sql/connection.h
index 4d84bb81dae..528f1e9c599 100644
--- a/chromium/sql/connection.h
+++ b/chromium/sql/connection.h
@@ -166,7 +166,7 @@ class SQL_EXPORT Connection {
   //
   // If no callback is set, the default action is to crash in debug
   // mode or return failure in release mode.
-  typedef base::Callback<void(int, Statement*)> ErrorCallback;
+  typedef base::RepeatingCallback<void(int, Statement*)> ErrorCallback;
   void set_error_callback(const ErrorCallback& callback) {
     error_callback_ = callback;
   }
@@ -563,7 +563,7 @@ class SQL_EXPORT Connection {
 
   // Accessors for global error-expecter, for injecting behavior during tests.
   // See test/scoped_error_expecter.h.
-  typedef base::Callback<bool(int)> ErrorExpecterCallback;
+  typedef base::RepeatingCallback<bool(int)> ErrorExpecterCallback;
   static ErrorExpecterCallback* current_expecter_cb_;
   static void SetErrorExpecter(ErrorExpecterCallback* expecter);
   static void ResetErrorExpecter();
diff --git a/chromium/sql/connection_unittest.cc b/chromium/sql/connection_unittest.cc
index c09106fb56b..3042fd7d0dc 100644
--- a/chromium/sql/connection_unittest.cc
+++ b/chromium/sql/connection_unittest.cc
@@ -90,8 +90,8 @@ class ScopedScalarFunction {
       sql::Connection& db,
       const char* function_name,
       int args,
-      base::Callback<void(sqlite3_context*,int,sqlite3_value**)> cb)
-      : db_(db.db_), function_name_(function_name), cb_(cb) {
+      base::RepeatingCallback<void(sqlite3_context*, int, sqlite3_value**)> cb)
+      : db_(db.db_), function_name_(function_name), cb_(std::move(cb)) {
     sqlite3_create_function_v2(db_, function_name, args, SQLITE_UTF8,
                                this, &Run, NULL, NULL, NULL);
   }
@@ -109,7 +109,7 @@ class ScopedScalarFunction {
 
   sqlite3* db_;
   const char* function_name_;
-  base::Callback<void(sqlite3_context*,int,sqlite3_value**)> cb_;
+  base::RepeatingCallback<void(sqlite3_context*, int, sqlite3_value**)> cb_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedScalarFunction);
 };
@@ -117,10 +117,8 @@ class ScopedScalarFunction {
 // Allow a test to add a SQLite commit hook in a scoped context.
 class ScopedCommitHook {
  public:
-  ScopedCommitHook(sql::Connection& db,
-                   base::Callback<int(void)> cb)
-      : db_(db.db_),
-        cb_(cb) {
+  ScopedCommitHook(sql::Connection& db, base::RepeatingCallback<int()> cb)
+      : db_(db.db_), cb_(std::move(cb)) {
     sqlite3_commit_hook(db_, &Run, this);
   }
   ~ScopedCommitHook() {
@@ -134,7 +132,7 @@ class ScopedCommitHook {
   }
 
   sqlite3* db_;
-  base::Callback<int(void)> cb_;
+  base::RepeatingCallback<int(void)> cb_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCommitHook);
 };
@@ -187,7 +185,7 @@ void ErrorCallbackSetHelper(sql::Connection* db,
                             int error, sql::Statement* stmt) {
   // The ref count should not go to zero when changing the callback.
   EXPECT_GT(*counter, 0u);
-  db->set_error_callback(base::Bind(&IgnoreErrorCallback));
+  db->set_error_callback(base::BindRepeating(&IgnoreErrorCallback));
   EXPECT_GT(*counter, 0u);
 }
 
@@ -414,7 +412,7 @@ TEST_F(SQLConnectionTest, ErrorCallback) {
   int error = SQLITE_OK;
   {
     sql::ScopedErrorCallback sec(
-        &db(), base::Bind(&sql::CaptureErrorCallback, &error));
+        &db(), base::BindRepeating(&sql::CaptureErrorCallback, &error));
     EXPECT_FALSE(db().Execute("INSERT INTO foo (id) VALUES (12)"));
 
     // Later versions of SQLite throw SQLITE_CONSTRAINT_UNIQUE.  The specific
@@ -432,7 +430,7 @@ TEST_F(SQLConnectionTest, ErrorCallback) {
     EXPECT_EQ(SQLITE_OK, error);
   }
 
-  // base::Bind() can curry arguments to be passed by const reference
+  // base::BindRepeating() can curry arguments to be passed by const reference
   // to the callback function.  If the callback function calls
   // re/set_error_callback(), the storage for those arguments can be
   // deleted while the callback function is still executing.
@@ -444,8 +442,8 @@ TEST_F(SQLConnectionTest, ErrorCallback) {
   {
     size_t count = 0;
     sql::ScopedErrorCallback sec(
-        &db(), base::Bind(&ErrorCallbackSetHelper,
-                          &db(), &count, RefCounter(&count)));
+        &db(), base::BindRepeating(&ErrorCallbackSetHelper, &db(), &count,
+                                   RefCounter(&count)));
 
     EXPECT_FALSE(db().Execute("INSERT INTO foo (id) VALUES (12)"));
   }
@@ -454,8 +452,8 @@ TEST_F(SQLConnectionTest, ErrorCallback) {
   {
     size_t count = 0;
     sql::ScopedErrorCallback sec(
-        &db(), base::Bind(&ErrorCallbackResetHelper,
-                          &db(), &count, RefCounter(&count)));
+        &db(), base::BindRepeating(&ErrorCallbackResetHelper, &db(), &count,
+                                   RefCounter(&count)));
 
     EXPECT_FALSE(db().Execute("INSERT INTO foo (id) VALUES (12)"));
   }
@@ -733,9 +731,8 @@ TEST_F(SQLConnectionTest, RazeCallbackReopen) {
     ASSERT_TRUE(expecter.SawExpectedErrors());
   }
 
-  db().set_error_callback(base::Bind(&RazeErrorCallback,
-                                     &db(),
-                                     SQLITE_CORRUPT));
+  db().set_error_callback(
+      base::BindRepeating(&RazeErrorCallback, &db(), SQLITE_CORRUPT));
 
   // When the PRAGMA calls in Open() raise SQLITE_CORRUPT, the error
   // callback will call RazeAndClose().  Open() will then fail and be
@@ -1014,9 +1011,8 @@ TEST_F(SQLConnectionTest, Poison) {
   // Test that poisoning the database during a transaction works (with errors).
   // RazeErrorCallback() poisons the database, the extra COMMIT causes
   // CommitTransaction() to throw an error while commiting.
-  db().set_error_callback(base::Bind(&RazeErrorCallback,
-                                     &db(),
-                                     SQLITE_ERROR));
+  db().set_error_callback(
+      base::BindRepeating(&RazeErrorCallback, &db(), SQLITE_ERROR));
   db().Close();
   ASSERT_TRUE(db().Open(db_path()));
   EXPECT_TRUE(db().BeginTransaction());
@@ -1302,7 +1298,8 @@ TEST_F(SQLConnectionTest, TimeQuery) {
 
   // Function to inject pauses into statements.
   sql::test::ScopedScalarFunction scoper(
-      db(), "milliadjust", 1, base::Bind(&sqlite_adjust_millis, &time_mock));
+      db(), "milliadjust", 1,
+      base::BindRepeating(&sqlite_adjust_millis, &time_mock));
 
   base::HistogramTester tester;
 
@@ -1340,7 +1337,8 @@ TEST_F(SQLConnectionTest, TimeUpdateAutocommit) {
 
   // Function to inject pauses into statements.
   sql::test::ScopedScalarFunction scoper(
-      db(), "milliadjust", 1, base::Bind(&sqlite_adjust_millis, &time_mock));
+      db(), "milliadjust", 1,
+      base::BindRepeating(&sqlite_adjust_millis, &time_mock));
 
   base::HistogramTester tester;
 
@@ -1382,14 +1380,15 @@ TEST_F(SQLConnectionTest, TimeUpdateTransaction) {
 
   // Function to inject pauses into statements.
   sql::test::ScopedScalarFunction scoper(
-      db(), "milliadjust", 1, base::Bind(&sqlite_adjust_millis, &time_mock));
+      db(), "milliadjust", 1,
+      base::BindRepeating(&sqlite_adjust_millis, &time_mock));
 
   base::HistogramTester tester;
 
   {
     // Make the commit slow.
     sql::test::ScopedCommitHook scoped_hook(
-        db(), base::Bind(adjust_commit_hook, &time_mock, 100));
+        db(), base::BindRepeating(adjust_commit_hook, &time_mock, 100));
     ASSERT_TRUE(db().BeginTransaction());
     EXPECT_TRUE(db().Execute(
         "INSERT INTO foo VALUES (11, milliadjust(10))"));
@@ -1643,7 +1642,7 @@ TEST_F(SQLConnectionTest, CompileError) {
   // DEATH tests not supported on Android, iOS, or Fuchsia.
 #if !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_FUCHSIA)
   if (DLOG_IS_ON(FATAL)) {
-    db().set_error_callback(base::Bind(&IgnoreErrorCallback));
+    db().set_error_callback(base::BindRepeating(&IgnoreErrorCallback));
     ASSERT_DEATH({
         db().GetUniqueStatement("SELECT x");
       }, "SQL compile error no such column: x");
diff --git a/chromium/sql/recovery_unittest.cc b/chromium/sql/recovery_unittest.cc
index 752688225d9..66df8193579 100644
--- a/chromium/sql/recovery_unittest.cc
+++ b/chromium/sql/recovery_unittest.cc
@@ -248,8 +248,8 @@ TEST_F(SQLRecoveryTest, RecoverCorruptIndex) {
   ASSERT_TRUE(Reopen());
 
   int error = SQLITE_OK;
-  db().set_error_callback(base::Bind(&RecoveryCallback, &db(), db_path(),
-                                     kCreateTable, kCreateIndex, &error));
+  db().set_error_callback(base::BindRepeating(
+      &RecoveryCallback, &db(), db_path(), kCreateTable, kCreateIndex, &error));
 
   // This works before the callback is called.
   const char kTrivialSql[] = "SELECT COUNT(*) FROM sqlite_master";
@@ -307,8 +307,8 @@ TEST_F(SQLRecoveryTest, RecoverCorruptTable) {
   ASSERT_TRUE(Reopen());
 
   int error = SQLITE_OK;
-  db().set_error_callback(base::Bind(&RecoveryCallback, &db(), db_path(),
-                                     kCreateTable, kCreateIndex, &error));
+  db().set_error_callback(base::BindRepeating(
+      &RecoveryCallback, &db(), db_path(), kCreateTable, kCreateIndex, &error));
 
   // Index shows one less than originally inserted.
   const char kCountSql[] = "SELECT COUNT (*) FROM x";
diff --git a/chromium/sql/sqlite_features_unittest.cc b/chromium/sql/sqlite_features_unittest.cc
index 867fe10b0fa..6585ce09700 100644
--- a/chromium/sql/sqlite_features_unittest.cc
+++ b/chromium/sql/sqlite_features_unittest.cc
@@ -54,7 +54,7 @@ class SQLiteFeaturesTest : public sql::SQLTestBase {
     // The error delegate will set |error_| and |sql_text_| when any sqlite
     // statement operation returns an error code.
     db().set_error_callback(
-        base::Bind(&CaptureErrorCallback, &error_, &sql_text_));
+        base::BindRepeating(&CaptureErrorCallback, &error_, &sql_text_));
   }
 
   void TearDown() override {
diff --git a/chromium/sql/statement_unittest.cc b/chromium/sql/statement_unittest.cc
index 654629ecfa5..441781c1668 100644
--- a/chromium/sql/statement_unittest.cc
+++ b/chromium/sql/statement_unittest.cc
@@ -66,7 +66,7 @@ TEST_F(SQLStatementTest, ErrorCallback) {
 
   int error = SQLITE_OK;
   sql::ScopedErrorCallback sec(
-      &db(), base::Bind(&sql::CaptureErrorCallback, &error));
+      &db(), base::BindRepeating(&sql::CaptureErrorCallback, &error));
 
   // Insert in the foo table the primary key. It is an error to insert
   // something other than an number. This error causes the error callback