[Chromecast] Add metric reporting to ConnectivityCheckerImpl

chromecast/net/connectivity_checker_impl.cc

 // Copyright 2015 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 "chromecast/net/connectivity_checker_impl.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/values.h"
+#include "chromecast/base/metrics/cast_metrics_helper.h"
+#include "chromecast/base/serializers.h"
 #include "chromecast/net/net_switches.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
@@ skipping 14 matching lines @@
 
 // Default url for connectivity checking.
 const char kDefaultConnectivityCheckUrl[] =
     "https://connectivitycheck.gstatic.com/generate_204";
 
 // Delay notification of network change events to smooth out rapid flipping.
 // Histogram "Cast.Network.Down.Duration.In.Seconds" shows 40% of network
 // downtime is less than 3 seconds.
 const char kNetworkChangedDelayInSeconds = 3;
 
+const char kMetricNameNetworkConnectivityErrorType[] =
+    "Network.Connectivity.ErrorType";
+
 }  // namespace
 
 ConnectivityCheckerImpl::ConnectivityCheckerImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : ConnectivityChecker(),
       task_runner_(task_runner),
       connected_(false),
       connection_type_(net::NetworkChangeNotifier::CONNECTION_NONE),
       check_errors_(0),
       network_changed_pending_(false) {
@@ skipping 112 matching lines @@
   url_request_.reset(nullptr);  // URLRequest::Cancel() is called in destructor.
 
   if (http_response_code < 400) {
     VLOG(1) << "Connectivity check succeeded";
     check_errors_ = 0;
     SetConnected(true);
     timeout_.Cancel();
     return;
   }
   VLOG(1) << "Connectivity check failed: " << http_response_code;
-  OnUrlRequestError();
+  OnUrlRequestError(ErrorType::BAD_HTTP_STATUS);
   timeout_.Cancel();
 }
 
 void ConnectivityCheckerImpl::OnReadCompleted(net::URLRequest* request,
                                               int bytes_read) {
   NOTREACHED();
 }
 
 void ConnectivityCheckerImpl::OnSSLCertificateError(
     net::URLRequest* request,
     const net::SSLInfo& ssl_info,
     bool fatal) {
   LOG(ERROR) << "OnSSLCertificateError: cert_status=" << ssl_info.cert_status;
   net::SSLClientSocket::ClearSessionCache();
-  OnUrlRequestError();
+  OnUrlRequestError(ErrorType::SSL_CERTIFICATE_ERROR);
   timeout_.Cancel();
 }
 
-void ConnectivityCheckerImpl::OnUrlRequestError() {
+void ConnectivityCheckerImpl::OnUrlRequestError(ErrorType type) {
+  // Only record a metric for the initial disconnect event
+  if (check_errors_ == 0)
+    RecordNetworkConnectivityErrorType(type);
+
   ++check_errors_;
   if (check_errors_ > kNumErrorsToNotifyOffline) {
     check_errors_ = kNumErrorsToNotifyOffline;
     SetConnected(false);
   }
   url_request_.reset(nullptr);
   // Check again.
   task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ConnectivityCheckerImpl::Check, this),
       base::TimeDelta::FromSeconds(kConnectivityPeriodSeconds));
 }
 
 void ConnectivityCheckerImpl::OnUrlRequestTimeout() {
   LOG(ERROR) << "time out";
-  OnUrlRequestError();
+  OnUrlRequestError(ErrorType::REQUEST_TIMEOUT);
 }
 
 void ConnectivityCheckerImpl::Cancel() {
   if (!url_request_.get())
     return;
   VLOG(2) << "Cancel connectivity check in progress";
   url_request_.reset(nullptr);  // URLRequest::Cancel() is called in destructor.
   timeout_.Cancel();
 }
 
+void ConnectivityCheckerImpl::RecordNetworkConnectivityErrorType(
+    ConnectivityCheckerImpl::ErrorType type) {
+  std::unique_ptr<base::DictionaryValue> cast_event(

[bcf, 2016/05/12 07:35:56]

Is there a better way of constructing metrics in chromium/src/chromecast? It
seems like most of the easy ways are in internal.

[halliwell, 2016/05/12 13:46:19]

CastMetricsHelper::RecordApplicationEventWIthValue is a helper that essentially
does what you've done here.

[bcf, 2016/05/12 17:04:10]

I saw this, but I wasn't sure we wanted to add the other parts (app_id,
session_id, sdk_version). I guess I can make a new 
CastMetricsHelper::RecordEventWIthValue

+      new base::DictionaryValue());
+  cast_event->SetString("name", kMetricNameNetworkConnectivityErrorType);
+  cast_event->SetDouble("time", base::TimeTicks::Now().ToInternalValue());
+  cast_event->SetInteger("value", static_cast<int>(type));
+  std::unique_ptr<std::string> message = SerializeToJson(*cast_event);
+  DCHECK(message != nullptr);
+  metrics::CastMetricsHelper::GetInstance()->RecordSimpleAction(*message);
+}
+
 }  // namespace chromecast