Replace deprecated base::NonThreadSafe in content/public/test in favor of SequenceChecker.

content/public/test/test_download_request_handler.cc

 // Copyright 2015 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 "content/public/test/test_download_request_handler.h"
 
 #include <inttypes.h>
 
 #include <memory>
 #include <utility>
@@ skipping 620 matching lines @@
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&Interceptor::Register, url_,
                  base::SequencedTaskRunnerHandle::Get()),
       base::Bind(&StoreValueAndInvokeClosure<base::WeakPtr<Interceptor>>,
                  run_loop.QuitClosure(), &interceptor_));
   run_loop.Run();
 }
 
 void TestDownloadRequestHandler::StartServing(const Parameters& parameters) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   Interceptor::JobFactory job_factory =
       base::Bind(&PartialResponseJob::Factory, parameters);
   // Interceptor, if valid, is already registered and serving requests. We just
   // need to set the correct job factory for it to start serving using the new
   // parameters.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&Interceptor::SetJobFactory, interceptor_, job_factory));
 }
 
 void TestDownloadRequestHandler::StartServingStaticResponse(
     const base::StringPiece& headers) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   Parameters parameters;
   parameters.on_start_handler = base::Bind(
       &RespondToOnStartedCallbackWithStaticHeaders, headers.as_string());
   StartServing(parameters);
 }
 
 // static
 void TestDownloadRequestHandler::GetPatternBytes(int seed,
                                                  int64_t starting_offset,
                                                  int length,
                                                  char* buffer) {
   int64_t seed_offset = starting_offset / sizeof(int64_t);
   int64_t first_byte_position = starting_offset % sizeof(int64_t);
   while (length > 0) {
     uint64_t data = XorShift64StarWithIndex(seed, seed_offset);
     int length_to_copy =
         std::min(length, static_cast<int>(sizeof(data) - first_byte_position));
     memcpy(buffer, reinterpret_cast<char*>(&data) + first_byte_position,
            length_to_copy);
     buffer += length_to_copy;
     length -= length_to_copy;
     ++seed_offset;
     first_byte_position = 0;
   }
 }
 
 TestDownloadRequestHandler::~TestDownloadRequestHandler() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&Interceptor::Unregister, interceptor_));
 }
 
 void TestDownloadRequestHandler::GetCompletedRequestInfo(
     TestDownloadRequestHandler::CompletedRequests* requests) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::RunLoop run_loop;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&Interceptor::GetAndResetCompletedRequests, interceptor_,
                  requests),
       run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace content