Remove call to MessageLoop::QuitWhenIdle() in network_time_tracker.cc.

components/network_time/network_time_tracker.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/network_time/network_time_tracker.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/tick_clock.h"
 #include "build/build_config.h"
 #include "components/client_update_protocol/ecdsa.h"
 #include "components/network_time/network_time_pref_names.h"
@@ skipping 156 matching lines @@
 
 NetworkTimeTracker::NetworkTimeTracker(
     std::unique_ptr<base::Clock> clock,
     std::unique_ptr<base::TickClock> tick_clock,
     PrefService* pref_service,
     scoped_refptr<net::URLRequestContextGetter> getter)
     : server_url_(kTimeServiceURL),
       max_response_size_(1024),
       backoff_(base::TimeDelta::FromMinutes(kBackoffMinutes)),
       getter_(std::move(getter)),
-      loop_(nullptr),
       clock_(std::move(clock)),
       tick_clock_(std::move(tick_clock)),
       pref_service_(pref_service) {
   const base::DictionaryValue* time_mapping =
       pref_service_->GetDictionary(prefs::kNetworkTimeMapping);
   double time_js = 0;
   double ticks_js = 0;
   double network_time_js = 0;
   double uncertainty_js = 0;
   if (time_mapping->GetDouble(kPrefTime, &time_js) &&
@@ skipping 82 matching lines @@
 void NetworkTimeTracker::SetMaxResponseSizeForTesting(size_t limit) {
   max_response_size_ = limit;
 }
 
 void NetworkTimeTracker::SetPublicKeyForTesting(const base::StringPiece& key) {
   query_signer_ = client_update_protocol::Ecdsa::Create(kKeyVersion, key);
 }
 
 bool NetworkTimeTracker::QueryTimeServiceForTesting() {
   CheckTime();
-  loop_ = base::MessageLoop::current();  // Gets Quit on completion.
   return time_fetcher_ != nullptr;
 }
 
 void NetworkTimeTracker::WaitForFetchForTesting(uint32_t nonce) {
   query_signer_->OverrideNonceForTesting(kKeyVersion, nonce);
-  base::RunLoop().Run();
+  base::RunLoop run_loop;
+  run_loop_for_testing_ = &run_loop;
+  run_loop.Run();
+  run_loop_for_testing_ = nullptr;
 }
 
 base::TimeDelta NetworkTimeTracker::GetTimerDelayForTesting() const {
   DCHECK(timer_.IsRunning());
   return timer_.GetCurrentDelay();
 }
 
 NetworkTimeTracker::NetworkTimeResult NetworkTimeTracker::GetNetworkTime(
     base::Time* network_time,
     base::TimeDelta* uncertainty) const {
@@ skipping 153 matching lines @@
   // long time.
   if (!UpdateTimeFromResponse()) {  // On error, back off.
     if (backoff_ < base::TimeDelta::FromDays(2)) {
       backoff_ *= 2;
     }
   } else {
     backoff_ = base::TimeDelta::FromMinutes(kBackoffMinutes);
   }
   QueueCheckTime(backoff_);
   time_fetcher_.reset();
-  if (loop_ != nullptr) {
-    loop_->QuitWhenIdle();
-    loop_ = nullptr;
-  }
+  if (run_loop_for_testing_ != nullptr)
+    run_loop_for_testing_->QuitWhenIdle();
 }
 
 void NetworkTimeTracker::QueueCheckTime(base::TimeDelta delay) {
   timer_.Start(FROM_HERE, delay, this, &NetworkTimeTracker::CheckTime);
 }
 
 bool NetworkTimeTracker::ShouldIssueTimeQuery() {
   // Do not query the time service if not enabled via Variations Service.
   if (!base::FeatureList::IsEnabled(kNetworkTimeServiceQuerying)) {
     return false;
   }
 
   // If GetNetworkTime() does not return NETWORK_TIME_AVAILABLE,
   // synchronization has been lost and a query is needed.
   base::Time network_time;
   if (GetNetworkTime(&network_time, nullptr) != NETWORK_TIME_AVAILABLE) {
     return true;
   }
 
   // Otherwise, make the decision at random.
   return base::RandDouble() < RandomQueryProbability();
 }
 
 }  // namespace network_time