Use modified URLRequest::Read() and delegate methods in components/

components/domain_reliability/monitor.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/domain_reliability/monitor.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace domain_reliability {
 
 namespace {
 
-int URLRequestStatusToNetError(const net::URLRequestStatus& status) {
-  switch (status.status()) {
-    case net::URLRequestStatus::SUCCESS:
-      return net::OK;
-    case net::URLRequestStatus::IO_PENDING:
-      return net::ERR_IO_PENDING;
-    case net::URLRequestStatus::CANCELED:
-      return net::ERR_ABORTED;
-    case net::URLRequestStatus::FAILED:
-      return status.error();
-    default:
-      NOTREACHED();
-      return net::ERR_UNEXPECTED;
-  }
-}
-
 // Creates a new beacon based on |beacon_template| but fills in the status,
 // chrome_error, and server_ip fields based on the endpoint and result of
 // |attempt|.
 //
 // If there is no matching status for the result, returns false (which
 // means the attempt should not result in a beacon being reported).
 std::unique_ptr<DomainReliabilityBeacon> CreateBeaconFromAttempt(
     const DomainReliabilityBeacon& beacon_template,
     const net::ConnectionAttempt& attempt) {
   std::string status;
@@ skipping 122 matching lines @@
 
 void DomainReliabilityMonitor::SetDiscardUploads(bool discard_uploads) {
   DCHECK(OnNetworkThread());
   DCHECK(moved_to_network_thread_);
   DCHECK(uploader_);
 
   uploader_->set_discard_uploads(discard_uploads);
   discard_uploads_set_ = true;
 }
 
+// TODO(maksims): Make this take net_error.

[davidben, 2016/09/06 17:07:28]

It does not appear this CL does not actually do anything to this directory
except lose the logic in URLRequestStatusToNetError. I think this TODO needs to
be resolved at the same time as converting this directory. So either remove the
changes to this directory and leave it for later or fully route the net_error
out of URLRequest correctly.

[maksims (do not use this acc), 2016/09/12 12:11:54]

Thank you for your feedback. I'll leave this for second iteration then after all
the other changes land, otherwise I'll have to change quite a lot, becuase this
method is overridden by other clients as well.

 void DomainReliabilityMonitor::OnBeforeRedirect(net::URLRequest* request) {
   DCHECK(OnNetworkThread());
   DCHECK(discard_uploads_set_);
 
   // Record the redirect itself in addition to the final request.
-  OnRequestLegComplete(RequestInfo(*request));
+  OnRequestLegComplete(RequestInfo(*request, request->status().error()));
 }
 
+// TODO(maksims): Make this take net_error.
 void DomainReliabilityMonitor::OnCompleted(net::URLRequest* request,
                                            bool started) {
   DCHECK(OnNetworkThread());
   DCHECK(discard_uploads_set_);
 
   if (!started)
     return;
-  RequestInfo request_info(*request);
+  RequestInfo request_info(*request, request->status().error());
   OnRequestLegComplete(request_info);
 
   if (request_info.response_info.network_accessed) {
     // A request was just using the network, so now is a good time to run any
     // pending and eligible uploads.
     dispatcher_.RunEligibleTasks();
   }
 }
 
 void DomainReliabilityMonitor::OnNetworkChanged(
@@ skipping 43 matching lines @@
 
   return base::MakeUnique<DomainReliabilityContext>(
       time_.get(), scheduler_params_, upload_reporter_string_,
       &last_network_change_time_, &dispatcher_, uploader_.get(),
       std::move(config));
 }
 
 DomainReliabilityMonitor::RequestInfo::RequestInfo() {}
 
 DomainReliabilityMonitor::RequestInfo::RequestInfo(
-    const net::URLRequest& request)
+    const net::URLRequest& request,
+    int error)
     : url(request.url()),
-      status(request.status()),
+      net_error(error),
       response_info(request.response_info()),
       load_flags(request.load_flags()),
       upload_depth(
           DomainReliabilityUploader::GetURLRequestUploadDepth(request)) {
   request.GetLoadTimingInfo(&load_timing_info);
   request.GetConnectionAttempts(&connection_attempts);
   request.PopulateNetErrorDetails(&details);
   if (!request.GetRemoteEndpoint(&remote_endpoint))
     remote_endpoint = net::IPEndPoint();
 }
 
 DomainReliabilityMonitor::RequestInfo::RequestInfo(const RequestInfo& other) =
     default;
 
 DomainReliabilityMonitor::RequestInfo::~RequestInfo() {}
 
 // static
 bool DomainReliabilityMonitor::RequestInfo::ShouldReportRequest(
     const DomainReliabilityMonitor::RequestInfo& request) {
   // Don't report requests that weren't supposed to send cookies.
   if (request.load_flags & net::LOAD_DO_NOT_SEND_COOKIES)
     return false;
 
   // Report requests that accessed the network or failed with an error code
   // that Domain Reliability is interested in.
   if (request.response_info.network_accessed)
     return true;
-  if (URLRequestStatusToNetError(request.status) != net::OK)
+  if (request.net_error != net::OK)
     return true;
   if (request.details.quic_port_migration_detected)
     return true;
 
   return false;
 }
 
 void DomainReliabilityMonitor::OnRequestLegComplete(
     const RequestInfo& request) {
   // Check these again because unit tests call this directly.
   DCHECK(OnNetworkThread());
   DCHECK(discard_uploads_set_);
 
   MaybeHandleHeader(request);
 
   if (!RequestInfo::ShouldReportRequest(request))
     return;
 
   int response_code;
   if (request.response_info.headers.get())
     response_code = request.response_info.headers->response_code();
   else
     response_code = -1;
 
-  net::ConnectionAttempt url_request_attempt(
-      request.remote_endpoint, URLRequestStatusToNetError(request.status));
+  net::ConnectionAttempt url_request_attempt(request.remote_endpoint,
+                                             request.net_error);
 
   DomainReliabilityBeacon beacon_template;
   if (request.response_info.connection_info !=
       net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN) {
     beacon_template.protocol =
         GetDomainReliabilityProtocol(request.response_info.connection_info,
                                      request.response_info.ssl_info.is_valid());
   } else {
     // Use the connection info from the network error details if the response
     // is unavailable.
@@ skipping 80 matching lines @@
       break;
   }
 }
 
 base::WeakPtr<DomainReliabilityMonitor>
 DomainReliabilityMonitor::MakeWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace domain_reliability