Fix Thread::SetMessageLoop(nullptr).

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/safe_browsing/protocol_manager.h"
 
 #include <utility>
 
 #include "base/environment.h"
 #include "base/logging.h"
@@ skipping 41 matching lines @@
   UPDATE_RESULT_BACKUP_NETWORK_SUCCESS,
   UPDATE_RESULT_MAX,
   UPDATE_RESULT_BACKUP_START = UPDATE_RESULT_BACKUP_CONNECT_FAIL,
 };
 
 void RecordUpdateResult(UpdateResult result) {
   DCHECK(result >= 0 && result < UPDATE_RESULT_MAX);
   UMA_HISTOGRAM_ENUMERATION("SB2.UpdateResult", result, UPDATE_RESULT_MAX);
 }
 
-const char kSBUpdateFrequencyFinchExperiment[] = "SafeBrowsingUpdateFrequency";
-const char kSBUpdateFrequencyFinchParam[] = "NextUpdateIntervalInMinutes";
+constexpr char kSBUpdateFrequencyFinchExperiment[] =
+    "SafeBrowsingUpdateFrequency";
+constexpr char kSBUpdateFrequencyFinchParam[] = "NextUpdateIntervalInMinutes";
 
 // This will be used for experimenting on a small subset of the population to
 // better estimate the benefit of updating the safe browsing hashes more
 // frequently.
 base::TimeDelta GetNextUpdateIntervalFromFinch() {
   std::string num_str = variations::GetVariationParamValue(
       kSBUpdateFrequencyFinchExperiment, kSBUpdateFrequencyFinchParam);
   int finch_next_update_interval_minutes = 0;
   if (!base::StringToInt(num_str, &finch_next_update_interval_minutes)) {
     finch_next_update_interval_minutes = 0;  // Defaults to 0.
   }
   return base::TimeDelta::FromMinutes(finch_next_update_interval_minutes);
 }
 
 }  // namespace
 
 namespace safe_browsing {
 
 // Minimum time, in seconds, from start up before we must issue an update query.
-static const int kSbTimerStartIntervalSecMin = 60;
+constexpr int kSbTimerStartIntervalSecMin = 60;
 
 // Maximum time, in seconds, from start up before we must issue an update query.
-static const int kSbTimerStartIntervalSecMax = 300;
+constexpr int kSbTimerStartIntervalSecMax = 300;
 
-// The maximum time, in seconds, to wait for a response to an update request.
-static const int kSbMaxUpdateWaitSec = 30;
+// The maximum time to wait for a response to an update request.
+constexpr base::TimeDelta kSbMaxUpdateWait = base::TimeDelta::FromSeconds(30);
 
 // Maximum back off multiplier.
-static const size_t kSbMaxBackOff = 8;
+constexpr size_t kSbMaxBackOff = 8;
 
-const char kGetHashUmaResponseMetricName[] = "SB2.GetHashResponseOrErrorCode";
-const char kGetChunkUmaResponseMetricName[] = "SB2.GetChunkResponseOrErrorCode";
+constexpr char kGetHashUmaResponseMetricName[] =
+    "SB2.GetHashResponseOrErrorCode";
+constexpr char kGetChunkUmaResponseMetricName[] =
+    "SB2.GetChunkResponseOrErrorCode";
 
 // The default SBProtocolManagerFactory.
 class SBProtocolManagerFactoryImpl : public SBProtocolManagerFactory {
  public:
   SBProtocolManagerFactoryImpl() {}
   ~SBProtocolManagerFactoryImpl() override {}
 
   std::unique_ptr<SafeBrowsingProtocolManager> CreateProtocolManager(
       SafeBrowsingProtocolManagerDelegate* delegate,
       net::URLRequestContextGetter* request_context_getter,
@@ skipping 77 matching lines @@
     const net::URLRequestStatus& status,
     int response_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       metric_name, status.is_success() ? response_code : status.error());
 }
 
 bool SafeBrowsingProtocolManager::IsUpdateScheduled() const {
   return update_timer_.IsRunning();
 }
 
+// static
+base::TimeDelta SafeBrowsingProtocolManager::GetUpdateTimeoutForTesting() {
+  return kSbMaxUpdateWait;
+}
+
 SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {}
 
 // We can only have one update or chunk request outstanding, but there may be
 // multiple GetHash requests pending since we don't want to serialize them and
 // slow down the user.
 void SafeBrowsingProtocolManager::GetFullHash(
     const std::vector<SBPrefix>& prefixes,
     FullHashCallback callback,
     bool is_download,
     ExtendedReportingLevel reporting_level) {
@@ skipping 380 matching lines @@
   request_ = net::URLFetcher::Create(url_fetcher_id_++, backup_update_url,
                                      net::URLFetcher::POST, this);
   data_use_measurement::DataUseUserData::AttachToFetcher(
       request_.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   request_->SetUploadData("text/plain", update_list_data_);
   request_->Start();
 
   // Begin the update request timeout.
-  timeout_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kSbMaxUpdateWaitSec),
-                       this,
+  timeout_timer_.Start(FROM_HERE, kSbMaxUpdateWait, this,
                        &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 
   return true;
 }
 
 void SafeBrowsingProtocolManager::IssueChunkRequest() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // We are only allowed to have one request outstanding at any time.  Also,
   // don't get the next url until the previous one has been written to disk so
   // that we don't use too much memory.
@@ skipping 60 matching lines @@
   request_ = net::URLFetcher::Create(url_fetcher_id_++, update_url,
                                      net::URLFetcher::POST, this);
   data_use_measurement::DataUseUserData::AttachToFetcher(
       request_.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   request_->SetUploadData("text/plain", update_list_data_);
   request_->Start();
 
   // Begin the update request timeout.
-  timeout_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kSbMaxUpdateWaitSec),
-                       this,
+  timeout_timer_.Start(FROM_HERE, kSbMaxUpdateWait, this,
                        &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 }
 
 // If we haven't heard back from the server with an update response, this method
 // will run. Close the current update session and schedule another update.
 void SafeBrowsingProtocolManager::UpdateResponseTimeout() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(request_type_ == UPDATE_REQUEST ||
          request_type_ == BACKUP_UPDATE_REQUEST);
   request_.reset();
@@ skipping 111 matching lines @@
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     const FullHashDetails& other) = default;
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing