Deprecate NonThreadSafe in components/safe_browsing_db in favor of SequenceChecker.

components/safe_browsing_db/v4_update_protocol_manager.cc

 // Copyright 2016 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/safe_browsing_db/v4_update_protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
@@ skipping 135 matching lines @@
                         kV4TimerStartIntervalSecMax))),
       config_(config),
       request_context_getter_(request_context_getter),
       url_fetcher_id_(0),
       update_callback_(update_callback),
       extended_reporting_level_callback_(extended_reporting_level_callback) {
   // Do not auto-schedule updates. Let the owner (V4LocalDatabaseManager) do it
   // when it is ready to process updates.
 }
 
-V4UpdateProtocolManager::~V4UpdateProtocolManager() {}
+V4UpdateProtocolManager::~V4UpdateProtocolManager() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
 
 bool V4UpdateProtocolManager::IsUpdateScheduled() const {
   return update_timer_.IsRunning();
 }
 
 void V4UpdateProtocolManager::ScheduleNextUpdate(
     std::unique_ptr<StoreStateMap> store_state_map) {
   store_state_map_ = std::move(store_state_map);
   ScheduleNextUpdateWithBackoff(false);
 }
 
 void V4UpdateProtocolManager::ScheduleNextUpdateWithBackoff(bool back_off) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (config_.disable_auto_update) {
     DCHECK(!IsUpdateScheduled());
     return;
   }
 
   // Reschedule with the new update.
   base::TimeDelta next_update_interval = GetNextUpdateInterval(back_off);
   ScheduleNextUpdateAfterInterval(next_update_interval);
 }
 
 // According to section 5 of the SafeBrowsing protocol specification, we must
 // back off after a certain number of errors.
 base::TimeDelta V4UpdateProtocolManager::GetNextUpdateInterval(bool back_off) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(next_update_interval_ > base::TimeDelta());
 
   base::TimeDelta next = next_update_interval_;
   if (back_off) {
     next = V4ProtocolManagerUtil::GetNextBackOffInterval(
         &update_error_count_, &update_back_off_mult_);
   }
 
   if (!last_response_time_.is_null()) {
     // The callback spent some time updating the database, including disk I/O.
     // Do not wait that extra time.
     base::TimeDelta callback_time = Time::Now() - last_response_time_;
     if (callback_time < next) {
       next -= callback_time;
     } else {
       // If the callback took too long, schedule the next update with no delay.
       next = base::TimeDelta();
     }
   }
   DVLOG(1) << "V4UpdateProtocolManager::GetNextUpdateInterval: "
            << "next_interval: " << next;
   return next;
 }
 
 void V4UpdateProtocolManager::ScheduleNextUpdateAfterInterval(
     base::TimeDelta interval) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(interval >= base::TimeDelta());
 
   // Unschedule any current timer.
   update_timer_.Stop();
   update_timer_.Start(FROM_HERE, interval, this,
                       &V4UpdateProtocolManager::IssueUpdateRequest);
 }
 
 std::string V4UpdateProtocolManager::GetBase64SerializedUpdateRequestProto() {
   DCHECK(!store_state_map_->empty());
@@ skipping 70 matching lines @@
     } else {
       std::unique_ptr<ListUpdateResponse> add(new ListUpdateResponse);
       add->Swap(&list_update_response);
       parsed_server_response->push_back(std::move(add));
     }
   }
   return true;
 }
 
 void V4UpdateProtocolManager::IssueUpdateRequest() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If an update request is already pending, record and return silently.
   if (request_.get()) {
     RecordUpdateResult(V4OperationResult::ALREADY_PENDING_ERROR);
     return;
   }
 
   std::string req_base64 = GetBase64SerializedUpdateRequestProto();
   GURL update_url;
   net::HttpRequestHeaders headers;
@@ skipping 50 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("SafeBrowsing.V4Update.TimedOut", true);
   request_.reset();
   ScheduleNextUpdateWithBackoff(false);
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // SafeBrowsing request responses are handled here.
 void V4UpdateProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   timeout_timer_.Stop();
 
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
   V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
       "SafeBrowsing.V4Update.Network.Result", status, response_code);
   UMA_HISTOGRAM_BOOLEAN("SafeBrowsing.V4Update.TimedOut", false);
 
   last_response_time_ = Time::Now();
@@ skipping 38 matching lines @@
 
 void V4UpdateProtocolManager::GetUpdateUrlAndHeaders(
     const std::string& req_base64,
     GURL* gurl,
     net::HttpRequestHeaders* headers) const {
   V4ProtocolManagerUtil::GetRequestUrlAndHeaders(
       req_base64, "threatListUpdates:fetch", config_, gurl, headers);
 }
 
 }  // namespace safe_browsing