Use TaskScheduler instead of SequencedWorkerPool in streaming_utf8_validator_unittest.cc.

base/i18n/streaming_utf8_validator_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/i18n/streaming_utf8_validator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 13 matching lines @@
 
 #ifdef BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
-#include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
-#include "base/threading/sequenced_worker_pool.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_scheduler.h"
 #include "third_party/icu/source/common/unicode/utf8.h"
 
 #endif  // BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
 namespace base {
 namespace {
 
 // Avoid having to qualify the enum values in the tests.
 const StreamingUtf8Validator::State VALID_ENDPOINT =
     StreamingUtf8Validator::VALID_ENDPOINT;
 const StreamingUtf8Validator::State VALID_MIDPOINT =
     StreamingUtf8Validator::VALID_MIDPOINT;
 const StreamingUtf8Validator::State INVALID = StreamingUtf8Validator::INVALID;
 
 #ifdef BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
 const uint32_t kThoroughTestChunkSize = 1 << 24;
 
 class StreamingUtf8ValidatorThoroughTest : public ::testing::Test {
  protected:
   StreamingUtf8ValidatorThoroughTest()
-      : all_done_(&lock_), tasks_dispatched_(0), tasks_finished_(0) {}
+      : tasks_dispatched_(0), tasks_finished_(0) {}
 
   // This uses the same logic as base::IsStringUTF8 except it considers
   // non-characters valid (and doesn't require a string as input).
   static bool IsStringUtf8(const char* src, int32_t src_len) {
     int32_t char_index = 0;
 
     while (char_index < src_len) {
       int32_t code_point;
       U8_NEXT(src, char_index, src_len, code_point);
       if (!base::IsValidCodepoint(code_point))
@@ skipping 25 matching lines @@
   // pool. Signals |all_done_| at the end if it thinks all tasks are
   // finished.
   void TestRange(uint32_t begin, uint32_t size) {
     for (uint32_t i = 0; i < size; ++i) {
       TestNumber(begin + i);
     }
     base::AutoLock al(lock_);
     ++tasks_finished_;
     LOG(INFO) << tasks_finished_ << " / " << tasks_dispatched_
               << " tasks done\n";
-    if (tasks_finished_ >= tasks_dispatched_) {
-      all_done_.Signal();
-    }
   }
 
  protected:
   base::Lock lock_;
-  base::ConditionVariable all_done_;
   int tasks_dispatched_;
   int tasks_finished_;
 };
 
 TEST_F(StreamingUtf8ValidatorThoroughTest, TestEverything) {
-  scoped_refptr<base::SequencedWorkerPool> pool =
-      new base::SequencedWorkerPool(32, "TestEverything");
-  base::AutoLock al(lock_);
-  uint32_t begin = 0;
-  do {
-    pool->PostWorkerTask(
-        FROM_HERE,
-        base::Bind(&StreamingUtf8ValidatorThoroughTest::TestRange,
-                   base::Unretained(this),
-                   begin,
-                   kThoroughTestChunkSize));
-    ++tasks_dispatched_;
-    begin += kThoroughTestChunkSize;
-  } while (begin != 0);
-  while (tasks_finished_ < tasks_dispatched_)
-    all_done_.Wait();
+  base::TaskScheduler::CreateAndStartWithDefaultParams(
+      "StreamingUtf8ValidatorThoroughTest");
+  {
+    base::AutoLock al(lock_);
+    uint32_t begin = 0;
+    do {
+      base::PostTaskWithTraits(
+          FROM_HERE, {base::TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          base::BindOnce(&StreamingUtf8ValidatorThoroughTest::TestRange,
+                         base::Unretained(this), begin,
+                         kThoroughTestChunkSize));
+      ++tasks_dispatched_;
+      begin += kThoroughTestChunkSize;
+    } while (begin != 0);
+  }
+  base::TaskScheduler::GetInstance()->Shutdown();
+  base::TaskScheduler::GetInstance()->JoinForTesting();
+  base::TaskScheduler::SetInstance(nullptr);
 }
 
 #endif  // BASE_I18N_UTF8_VALIDATOR_THOROUGH_TEST
 
 // These valid and invalid UTF-8 sequences are based on the tests from
 // base/strings/string_util_unittest.cc
 
 // All of the strings in |valid| must represent a single codepoint, because
 // partial sequences are constructed by taking non-empty prefixes of these
 // strings.
@@ skipping 262 matching lines @@
 TEST(StreamingUtf8ValidatorValidateTest, SimpleInvalidCase) {
   EXPECT_FALSE(StreamingUtf8Validator::Validate("\xc0\x80"));
 }
 
 TEST(StreamingUtf8ValidatorValidateTest, TruncatedIsInvalid) {
   EXPECT_FALSE(StreamingUtf8Validator::Validate("\xc2"));
 }
 
 }  // namespace
 }  // namespace base