Added ClientEvent proto and structure for storing events in the factory.

google_apis/gcm/engine/connection_factory_impl.cc

 // Copyright (c) 2013 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 "google_apis/gcm/engine/connection_factory_impl.h"
 
 #include <string>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
@@ skipping 106 matching lines @@
 
   if (connecting_ || waiting_for_backoff_)
     return;  // Connection attempt already in progress or pending.
 
   if (IsEndpointReachable())
     return;  // Already connected.
 
   ConnectWithBackoff();
 }
 
+ConnectionEventTracker* ConnectionFactoryImpl::GetEventTrackerForTesting() {
+  return &event_tracker_;
+}
+
 void ConnectionFactoryImpl::ConnectWithBackoff() {
   // If a canary managed to connect while a backoff expiration was pending,
   // just cleanup the internal state.
   if (connecting_ || logging_in_ || IsEndpointReachable()) {
     waiting_for_backoff_ = false;
     return;
   }
 
   if (backoff_entry_->ShouldRejectRequest()) {
     DVLOG(1) << "Delaying MCS endpoint connection for "
@@ skipping 61 matching lines @@
   if (!last_login_time_.is_null()) {
     UMA_HISTOGRAM_CUSTOM_TIMES("GCM.ConnectionUpTime",
                                NowTicks() - last_login_time_,
                                base::TimeDelta::FromSeconds(1),
                                base::TimeDelta::FromHours(24),
                                50);
     // |last_login_time_| will be reset below, before attempting the new
     // connection.
   }
 
+  if (logging_in_)
+    event_tracker_.ConnectionLoginFailed();
+  event_tracker_.EndConnectionAttempt();
+
   CloseSocket();
   DCHECK(!IsEndpointReachable());
 
   // TODO(zea): if the network is offline, don't attempt to connect.
   // See crbug.com/396687
 
   // Network changes get special treatment as they can trigger a one-off canary
   // request that bypasses backoff (but does nothing if a connection is in
   // progress). Other connection reset events can be ignored as a connection
   // is already awaiting backoff expiration.
@@ skipping 71 matching lines @@
 
   net::IPEndPoint ip_endpoint;
   int result = socket_handle_.socket()->GetPeerAddress(&ip_endpoint);
   if (result != net::OK)
     return net::IPEndPoint();
 
   return ip_endpoint;
 }
 
 void ConnectionFactoryImpl::ConnectImpl() {
+  event_tracker_.StartConnectionAttempt();
+  StartConnection();
+}
+
+void ConnectionFactoryImpl::StartConnection() {
   DCHECK(!IsEndpointReachable());
   // TODO(zea): Make this a dcheck again. crbug.com/462319
   CHECK(!socket_handle_.socket());
 
   // TODO(zea): if the network is offline, don't attempt to connect.
   // See crbug.com/396687
 
   connecting_ = true;
   GURL current_endpoint = GetCurrentEndpoint();
   recorder_->RecordConnectionInitiated(current_endpoint.host());
@@ skipping 10 matching lines @@
   if (status != net::ERR_IO_PENDING)
     OnProxyResolveDone(status);
 }
 
 void ConnectionFactoryImpl::InitHandler() {
   // May be null in tests.
   mcs_proto::LoginRequest login_request;
   if (!request_builder_.is_null()) {
     request_builder_.Run(&login_request);
     DCHECK(login_request.IsInitialized());
+    event_tracker_.WriteToLoginRequest(&login_request);
   }
 
   connection_handler_->Init(login_request, socket_handle_.socket());
 }
 
 std::unique_ptr<net::BackoffEntry> ConnectionFactoryImpl::CreateBackoffEntry(
     const net::BackoffEntry::Policy* const policy) {
   return std::unique_ptr<net::BackoffEntry>(new net::BackoffEntry(policy));
 }
 
@@ skipping 25 matching lines @@
     DCHECK_NE(result, net::OK);
     if (result == net::ERR_IO_PENDING)
       return;  // Proxy reconsideration pending. Return.
     LOG(ERROR) << "Failed to connect to MCS endpoint with error " << result;
     UMA_HISTOGRAM_BOOLEAN("GCM.ConnectionSuccessRate", false);
     recorder_->RecordConnectionFailure(result);
     CloseSocket();
     backoff_entry_->InformOfRequest(false);
     UMA_HISTOGRAM_SPARSE_SLOWLY("GCM.ConnectionFailureErrorCode", result);
 
+    event_tracker_.ConnectionAttemptFailed(result);
+    event_tracker_.EndConnectionAttempt();
+
     // If there are other endpoints available, use the next endpoint on the
     // subsequent retry.
     next_endpoint_++;
     if (next_endpoint_ >= mcs_endpoints_.size())
       next_endpoint_ = 0;
     connecting_ = false;
     Connect();
     return;
   }
 
@@ skipping 28 matching lines @@
 
   // Handshake complete, reset backoff. If the login failed with an error,
   // the client should invoke SignalConnectionReset(LOGIN_FAILURE), which will
   // restore the previous backoff.
   DVLOG(1) << "Handshake complete.";
   last_login_time_ = NowTicks();
   previous_backoff_.swap(backoff_entry_);
   backoff_entry_->Reset();
   logging_in_ = false;
 
+  event_tracker_.ConnectionAttemptSucceeded();
+
   if (listener_)
     listener_->OnConnected(GetCurrentEndpoint(), GetPeerIP());
 }
 
 // This has largely been copied from
 // HttpStreamFactoryImpl::Job::DoResolveProxyComplete. This should be
 // refactored into some common place.
 void ConnectionFactoryImpl::OnProxyResolveDone(int status) {
   pac_request_ = NULL;
   DVLOG(1) << "Proxy resolution status: " << status;
@@ skipping 141 matching lines @@
 
 void ConnectionFactoryImpl::RebuildNetworkSessionAuthCache() {
   if (!http_network_session_ || !http_network_session_->http_auth_cache())
     return;
 
   gcm_network_session_->http_auth_cache()->UpdateAllFrom(
       *http_network_session_->http_auth_cache());
 }
 
 }  // namespace gcm