Job Controller: clean up metrics logging about the job racing result

net/http/http_stream_factory_impl_job_controller.cc

 // Copyright (c) 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 "net/http/http_stream_factory_impl_job_controller.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 728 matching lines @@
     // we've already got one available for a different hostname where the ip
     // address matches up?
     CancelJobs();
     return;
   }
 
   if (job->job_type() == MAIN && alternative_job_failed_)
     ReportBrokenAlternativeService();
 
   if (!bound_job_) {
-    if (main_job_ && alternative_job_) {
-      job->ReportJobSucceededForRequest();
-      MaybeRecordAlternativeProxyServerUsage(job);
-    }
+    if (main_job_ && alternative_job_)
+      ReportAlternateProtocolUsage(job);
     BindJob(job);
     return;
   }
   DCHECK(bound_job_);
 }
 
 void HttpStreamFactoryImpl::JobController::MarkRequestComplete(
     bool was_alpn_negotiated,
     NextProto negotiated_protocol,
     bool using_spdy) {
@@ skipping 136 matching lines @@
   // First Alt-Svc that is not marked as broken.
   AlternativeService first_alternative_service;
 
   for (const AlternativeService& alternative_service :
        alternative_service_vector) {
     DCHECK(IsAlternateProtocolValid(alternative_service.protocol));
     if (!quic_advertised && alternative_service.protocol == QUIC)
       quic_advertised = true;
     if (http_server_properties.IsAlternativeServiceBroken(
             alternative_service)) {
-      HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN);
+      HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN, false);
       continue;
     }
 
 
     // Some shared unix systems may have user home directories (like
     // http://foo.com/~mike) which allow users to emit headers.  This is a bad
     // idea already, but with Alternate-Protocol, it provides the ability for a
     // single user on a multi-user system to hijack the alternate protocol.
     // These systems also enforce ports <1024 as restricted ports.  So don't
     // allow protocol upgrades to user-controllable ports.
@@ skipping 127 matching lines @@
     // Check that QUIC is enabled globally, and it is not disabled.
     if (!session_->params().enable_quic ||
         session_->quic_stream_factory()->IsQuicDisabled()) {
       return false;
     }
   }
 
   return true;
 }
 
-void HttpStreamFactoryImpl::JobController::
-    MaybeRecordAlternativeProxyServerUsage(Job* job) const {
-  if (is_preconnect_ ||
-      !alternative_job_->alternative_proxy_server().is_quic()) {
+void HttpStreamFactoryImpl::JobController::ReportAlternateProtocolUsage(
+    Job* job) const {
+  DCHECK(main_job_ && alternative_job_);
+
+  bool proxy_server_used =
+      alternative_job_->alternative_proxy_server().is_quic();
+
+  if (job == main_job_.get()) {
+    HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_LOST_RACE,
+                                    proxy_server_used);
     return;
   }
-  DCHECK(main_job_.get() == job || alternative_job_.get() == job);
 
-  enum AlternativeProxyUsage {
-    ALTERNATIVE_PROXY_USAGE_NO_RACE = 0,
-    ALTERNATIVE_PROXY_USAGE_WON_RACE,
-    ALTERNATIVE_PROXY_USAGE_LOST_RACE,
-    ALTERNATIVE_PROXY_USAGE_MAX,
-  };
-  AlternativeProxyUsage alternative_proxy_usage = ALTERNATIVE_PROXY_USAGE_MAX;
+  DCHECK_EQ(alternative_job_.get(), job);
+  if (job->using_existing_quic_session()) {
+    HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_NO_RACE,
+                                    proxy_server_used);
+    return;
+  }
 
-  if (alternative_job_->using_existing_quic_session()) {
-    // If an existing session was used, then no TCP connection was
-    // started.
-    alternative_proxy_usage = ALTERNATIVE_PROXY_USAGE_NO_RACE;
-  } else if (job->alternative_proxy_server().is_quic()) {
-    // |job| was the alternative Job, and hence won the race.
-    alternative_proxy_usage = ALTERNATIVE_PROXY_USAGE_WON_RACE;
-  } else {
-    // |job| was the normal Job, and hence the alternative Job lost the race.
-    alternative_proxy_usage = ALTERNATIVE_PROXY_USAGE_LOST_RACE;
-  }
-  DCHECK_NE(ALTERNATIVE_PROXY_USAGE_MAX, alternative_proxy_usage);
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicAlternativeProxy.Usage",
-                            alternative_proxy_usage,
-                            ALTERNATIVE_PROXY_USAGE_MAX);
+  HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_WON_RACE,
+                                  proxy_server_used);
 }
 
 void HttpStreamFactoryImpl::JobController::StartAlternativeProxyServerJob() {
   if (!alternative_job_ || !request_)
     return;
   DCHECK(alternative_job_->alternative_proxy_server().is_valid());
   alternative_job_->Start(request_->stream_type());
 }
 
 }  // namespace net