Revert of Add a NetworkQualityEstimator to TestURLRequestContext.

net/http/http_transaction_test_util.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 "net/http/http_transaction_test_util.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/clock.h"
+#include "base/time/time.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/cert/x509_certificate.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/log/net_log.h"
@@ skipping 210 matching lines @@
       weak_factory_(this) {}
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const HttpRequestInfo* request,
                                   const CompletionCallback& callback,
                                   const NetLogWithSource& net_log) {
   if (request_)
     return ERR_FAILED;
 
-  start_time_ = base::TimeTicks::Now();
   request_ = request;
   return StartInternal(request, callback, net_log);
 }
 
 int MockNetworkTransaction::RestartIgnoringLastError(
     const CompletionCallback& callback) {
   return ERR_FAILED;
 }
 
 int MockNetworkTransaction::RestartWithCertificate(
@@ skipping 100 matching lines @@
     QuicServerInfo* quic_server_info) {
 }
 
 bool MockNetworkTransaction::GetLoadTimingInfo(
     LoadTimingInfo* load_timing_info) const {
   if (socket_log_id_ != NetLogSource::kInvalidId) {
     // The minimal set of times for a request that gets a response, assuming it
     // gets a new socket.
     load_timing_info->socket_reused = false;
     load_timing_info->socket_log_id = socket_log_id_;
-    load_timing_info->connect_timing.connect_start = start_time_;
-    load_timing_info->connect_timing.connect_end = start_time_;
-    load_timing_info->send_start = start_time_;
-    load_timing_info->send_end = start_time_;
+    load_timing_info->connect_timing.connect_start = base::TimeTicks::Now();
+    load_timing_info->connect_timing.connect_end = base::TimeTicks::Now();
+    load_timing_info->send_start = base::TimeTicks::Now();
+    load_timing_info->send_end = base::TimeTicks::Now();
   } else {
     // If there's no valid socket ID, just use the generic socket reused values.
     // No tests currently depend on this, just should not match the values set
     // by a cache hit.
     load_timing_info->socket_reused = true;
-    load_timing_info->send_start = start_time_;
-    load_timing_info->send_end = start_time_;
+    load_timing_info->send_start = base::TimeTicks::Now();
+    load_timing_info->send_end = base::TimeTicks::Now();
   }
   return true;
 }
 
 bool MockNetworkTransaction::GetRemoteEndpoint(IPEndPoint* endpoint) const {
   *endpoint = IPEndPoint(IPAddress(127, 0, 0, 1), 80);
   return true;
 }
 
 void MockNetworkTransaction::SetPriority(RequestPriority priority) {
@@ skipping 185 matching lines @@
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return OK;
 }
 
 }  // namespace net