Deprecate NonThreadSafe in components/sync in favor of SequenceChecker.

components/sync/engine_impl/attachments/attachment_uploader_impl_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 "components/sync/engine_impl/attachments/attachment_uploader_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/engine/attachments/attachment_util.h"
 #include "components/sync/model/attachments/attachment.h"
 #include "components/sync/protocol/sync.pb.h"
@@ skipping 109 matching lines @@
 void MockOAuth2TokenService::InvalidateAccessTokenImpl(
     const std::string& account_id,
     const std::string& client_id,
     const ScopeSet& scopes,
     const std::string& access_token) {
   ++num_invalidate_token_;
   last_token_invalidated_ = access_token;
 }
 
 class TokenServiceProvider
-    : public OAuth2TokenServiceRequest::TokenServiceProvider,
-      base::NonThreadSafe {
+    : public OAuth2TokenServiceRequest::TokenServiceProvider {
  public:
   explicit TokenServiceProvider(OAuth2TokenService* token_service);
 
   // OAuth2TokenService::TokenServiceProvider implementation.
   scoped_refptr<base::SingleThreadTaskRunner> GetTokenServiceTaskRunner()
       override;
   OAuth2TokenService* GetTokenService() override;
 
  private:
   ~TokenServiceProvider() override;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   OAuth2TokenService* token_service_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
 };
 
 TokenServiceProvider::TokenServiceProvider(OAuth2TokenService* token_service)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       token_service_(token_service) {
   DCHECK(token_service_);
 }
 
-TokenServiceProvider::~TokenServiceProvider() {}
+TokenServiceProvider::~TokenServiceProvider() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
 
 scoped_refptr<base::SingleThreadTaskRunner>
 TokenServiceProvider::GetTokenServiceTaskRunner() {
   return task_runner_;
 }
 
 OAuth2TokenService* TokenServiceProvider::GetTokenService() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return token_service_;
 }
 
 // Text fixture for AttachmentUploaderImpl test.
 //
 // This fixture provides an embedded HTTP server and a mock OAuth2 token service
 // for interacting with AttachmentUploaderImpl
-class AttachmentUploaderImplTest : public testing::Test,
-                                   public base::NonThreadSafe {
+class AttachmentUploaderImplTest : public testing::Test {
  public:
   void OnRequestReceived(const HttpRequest& request);
 
  protected:
   AttachmentUploaderImplTest();
+  ~AttachmentUploaderImplTest() override;
   void SetUp() override;
   void TearDown() override;
 
   // Run the message loop until UploadDone has been invoked |num_uploads| times.
   void RunAndWaitFor(int num_uploads);
 
   // Upload an attachment and have the server respond with |status_code|.
   //
   // Returns the attachment that was uploaded.
   Attachment UploadAndRespondWith(const net::HttpStatusCode& status_code);
@@ skipping 18 matching lines @@
   std::unique_ptr<AttachmentUploader> uploader_;
   AttachmentUploader::UploadCallback upload_callback_;
   net::EmbeddedTestServer server_;
   // A closure that signals an upload has finished.
   base::Closure signal_upload_done_;
   std::vector<HttpRequest> http_requests_received_;
   std::vector<AttachmentUploader::UploadResult> upload_results_;
   std::vector<AttachmentId> attachment_ids_;
   std::unique_ptr<MockOAuth2TokenService> token_service_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   // Must be last data member.
   base::WeakPtrFactory<AttachmentUploaderImplTest> weak_ptr_factory_;
 };
 
 // Handles HTTP requests received by the EmbeddedTestServer.
 //
 // Responds with HTTP_OK by default.  See |SetStatusCode|.
-class RequestHandler : public base::NonThreadSafe {
+class RequestHandler {
  public:
   // Construct a RequestHandler that will PostTask to |test| using
   // |test_task_runner|.
   RequestHandler(
       const scoped_refptr<base::SingleThreadTaskRunner>& test_task_runner,
       const base::WeakPtr<AttachmentUploaderImplTest>& test);
 
   ~RequestHandler();
 
   std::unique_ptr<HttpResponse> HandleRequest(const HttpRequest& request);
 
   // Set the HTTP status code to respond with.
   void SetStatusCode(const net::HttpStatusCode& status_code);
 
   // Returns the HTTP status code that will be used in responses.
   net::HttpStatusCode GetStatusCode() const;
 
  private:
   // Protects status_code_.
   mutable base::Lock mutex_;
   net::HttpStatusCode status_code_;
 
   scoped_refptr<base::SingleThreadTaskRunner> test_task_runner_;
   base::WeakPtr<AttachmentUploaderImplTest> test_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
 };
 
 AttachmentUploaderImplTest::AttachmentUploaderImplTest()
     : weak_ptr_factory_(this) {}
 
+AttachmentUploaderImplTest::~AttachmentUploaderImplTest() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
 void AttachmentUploaderImplTest::OnRequestReceived(const HttpRequest& request) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   http_requests_received_.push_back(request);
 }
 
 void AttachmentUploaderImplTest::SetUp() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   request_handler_ = base::MakeUnique<RequestHandler>(
       message_loop_.task_runner(), weak_ptr_factory_.GetWeakPtr());
   url_request_context_getter_ =
       new net::TestURLRequestContextGetter(message_loop_.task_runner());
 
   server_.RegisterRequestHandler(
       base::Bind(&RequestHandler::HandleRequest,
                  base::Unretained(request_handler_.get())));
   ASSERT_TRUE(server_.Start());
 
@@ skipping 67 matching lines @@
   return message_loop_;
 }
 
 RequestHandler& AttachmentUploaderImplTest::request_handler() {
   return *request_handler_;
 }
 
 void AttachmentUploaderImplTest::UploadDone(
     const AttachmentUploader::UploadResult& result,
     const AttachmentId& attachment_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   upload_results_.push_back(result);
   attachment_ids_.push_back(attachment_id);
   DCHECK(!signal_upload_done_.is_null());
   signal_upload_done_.Run();
 }
 
 RequestHandler::RequestHandler(
     const scoped_refptr<base::SingleThreadTaskRunner>& test_task_runner,
     const base::WeakPtr<AttachmentUploaderImplTest>& test)
     : status_code_(net::HTTP_OK),
       test_task_runner_(test_task_runner),
       test_(test) {
-  DetachFromThread();
+  DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
-RequestHandler::~RequestHandler() {
-  DetachFromThread();
-}
+RequestHandler::~RequestHandler() = default;
 
 std::unique_ptr<HttpResponse> RequestHandler::HandleRequest(
     const HttpRequest& request) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   test_task_runner_->PostTask(
       FROM_HERE, base::Bind(&AttachmentUploaderImplTest::OnRequestReceived,
                             test_, request));
   std::unique_ptr<BasicHttpResponse> response(new BasicHttpResponse);
   response->set_code(GetStatusCode());
   response->set_content_type("text/plain");
   return std::move(response);
 }
 
 void RequestHandler::SetStatusCode(const net::HttpStatusCode& status_code) {
@@ skipping 269 matching lines @@
   scoped_refptr<base::RefCountedString> hello_world(new base::RefCountedString);
   hello_world->data() = "hello world";
   EXPECT_EQ("yZRlqg==", AttachmentUploaderImpl::FormatCrc32cHash(
                             ComputeCrc32c(hello_world)));
 }
 
 // TODO(maniscalco): Add test case for when we are uploading an attachment that
 // already exists.  409 Conflict? (bug 379825)
 
 }  // namespace syncer