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

google_apis/gcm/engine/connection_factory_impl.h

 // 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.
 
 #ifndef GOOGLE_APIS_GCM_ENGINE_CONNECTION_FACTORY_IMPL_H_
 #define GOOGLE_APIS_GCM_ENGINE_CONNECTION_FACTORY_IMPL_H_
 
 #include "google_apis/gcm/engine/connection_factory.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
+#include "google_apis/gcm/engine/connection_event_tracker.h"
 #include "google_apis/gcm/engine/connection_handler.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/network_change_notifier.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/client_socket_handle.h"
 #include "url/gurl.h"
 
@@ skipping 47 matching lines @@
   // Returns the server to which the factory is currently connected, or if
   // a connection is currently pending, the server to which the next connection
   // attempt will be made.
   GURL GetCurrentEndpoint() const;
 
   // Returns the IPEndpoint to which the factory is currently connected. If no
   // connection is active, returns an empty IPEndpoint.
   net::IPEndPoint GetPeerIP();
 
  protected:
-  // Implementation of Connect(..). If not in backoff, uses |login_request_|
-  // in attempting a connection/handshake. On connection/handshake failure, goes
-  // into backoff.
+  // Initiate the connection to the GCM server.
   // Virtual for testing.
-  virtual void ConnectImpl();
+  virtual void StartConnection();
 
   // Helper method for initalizing the connection hander.
   // Virtual for testing.
   virtual void InitHandler();
 
   // Helper method for creating a backoff entry.
   // Virtual for testing.
   virtual std::unique_ptr<net::BackoffEntry> CreateBackoffEntry(
       const net::BackoffEntry::Policy* const policy);
 
   // Helper method for creating the connection handler.
   // Virtual for testing.
   virtual std::unique_ptr<ConnectionHandler> CreateConnectionHandler(
       base::TimeDelta read_timeout,
       const ConnectionHandler::ProtoReceivedCallback& read_callback,
       const ConnectionHandler::ProtoSentCallback& write_callback,
       const ConnectionHandler::ConnectionChangedCallback& connection_callback);
 
   // Returns the current time in Ticks.
   // Virtual for testing.
   virtual base::TimeTicks NowTicks();
 
   // Callback for Socket connection completion.
   void OnConnectDone(int result);
 
   // ConnectionHandler callback for connection issues.
   void ConnectionHandlerCallback(int result);
 
  private:
+  friend class ConnectionFactoryImplTest;
+
+  ConnectionEventTracker* GetEventTrackerForTesting();
+
   // Helper method for checking backoff and triggering a connection as
   // necessary.
   void ConnectWithBackoff();
 
+  // Implementation of Connect(..). If not in backoff attempts a connection and
+  // handshake. On connection/handshake failure, goes into backoff.
+  void ConnectImpl();
+
   // Proxy resolution and connection functions.
   void OnProxyResolveDone(int status);
   void OnProxyConnectDone(int status);
   int ReconsiderProxyAfterError(int error);
   void ReportSuccessfulProxyConnection();
 
   // Closes the local socket if one is present, and resets connection handler.
   void CloseSocket();
 
   // Updates the GCM Network Session's HttpAuthCache with the HTTP Network
   // Session's cache, if available.
   void RebuildNetworkSessionAuthCache();
 
+  // The tracker will maintain a list of all connection attempts with GCM,
+  // whether they succeeded, and their duration.
+  ConnectionEventTracker event_tracker_;
+
   // The MCS endpoints to make connections to, sorted in order of priority.
   const std::vector<GURL> mcs_endpoints_;
   // Index to the endpoint for which a connection should be attempted next.
   size_t next_endpoint_;
   // Index to the endpoint that was last successfully connected.
   size_t last_successful_endpoint_;
 
   // The backoff policy to use.
   const net::BackoffEntry::Policy backoff_policy_;
 
@@ skipping 57 matching lines @@
   ConnectionListener* listener_;
 
   base::WeakPtrFactory<ConnectionFactoryImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionFactoryImpl);
 };
 
 }  // namespace gcm
 
 #endif  // GOOGLE_APIS_GCM_ENGINE_CONNECTION_FACTORY_IMPL_H_