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

google_apis/gcm/engine/connection_factory_impl_unittest.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 <cmath>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 72 matching lines @@
 // A connection factory that stubs out network requests and overrides the
 // backoff policy.
 class TestConnectionFactoryImpl : public ConnectionFactoryImpl {
  public:
   TestConnectionFactoryImpl(const base::Closure& finished_callback);
   ~TestConnectionFactoryImpl() override;
 
   void InitializeFactory();
 
   // Overridden stubs.
-  void ConnectImpl() override;
+  void StartConnection() override;
   void InitHandler() override;
   std::unique_ptr<net::BackoffEntry> CreateBackoffEntry(
       const net::BackoffEntry::Policy* const policy) override;
   std::unique_ptr<ConnectionHandler> CreateConnectionHandler(
       base::TimeDelta read_timeout,
       const ConnectionHandler::ProtoReceivedCallback& read_callback,
       const ConnectionHandler::ProtoSentCallback& write_callback,
       const ConnectionHandler::ConnectionChangedCallback& connection_callback)
       override;
   base::TimeTicks NowTicks() override;
 
   // Helpers for verifying connection attempts are made. Connection results
   // must be consumed.
   void SetConnectResult(int connect_result);
   void SetMultipleConnectResults(int connect_result, int num_expected_attempts);
 
   // Force a login handshake to be delayed.
   void SetDelayLogin(bool delay_login);
 
   // Simulate a socket error.
   void SetSocketError();
 
+  // Get the client events recorded by the factory.
+  const google::protobuf::RepeatedPtrField<mcs_proto::ClientEvent>*
+  GetClientEventsForTest() {
+    return &client_events_;
+  }
+
   base::SimpleTestTickClock* tick_clock() { return &tick_clock_; }
 
  private:
   // Clock for controlling delay.
   base::SimpleTestTickClock tick_clock_;
   // The result to return on the next connect attempt.
   int connect_result_;
   // The number of expected connection attempts;
   int num_expected_attempts_;
   // Whether all expected connection attempts have been fulfilled since an
@@ skipping 30 matching lines @@
                                     base::Bind(&WriteContinuation))),
       fake_handler_(scoped_handler_.get()) {
   // Set a non-null time.
   tick_clock_.Advance(base::TimeDelta::FromMilliseconds(1));
 }
 
 TestConnectionFactoryImpl::~TestConnectionFactoryImpl() {
   EXPECT_EQ(0, num_expected_attempts_);
 }
 
-void TestConnectionFactoryImpl::ConnectImpl() {
+void TestConnectionFactoryImpl::StartConnection() {
   ASSERT_GT(num_expected_attempts_, 0);
   ASSERT_FALSE(GetConnectionHandler()->CanSendMessage());
   std::unique_ptr<mcs_proto::LoginRequest> request(BuildLoginRequest(0, 0, ""));
   GetConnectionHandler()->Init(*request, NULL);
   OnConnectDone(connect_result_);
   if (!NextRetryAttempt().is_null()) {
     // Advance the time to the next retry time.
     base::TimeDelta time_till_retry =
         NextRetryAttempt() - tick_clock_.NowTicks();
     tick_clock_.Advance(time_till_retry);
@@ skipping 184 matching lines @@
   base::TimeTicks connect_time = factory()->tick_clock()->NowTicks();
   factory()->Connect();
   WaitForConnections();
   EXPECT_FALSE(factory()->IsEndpointReachable());
   EXPECT_FALSE(connected_server().is_valid());
   base::TimeTicks retry_time = factory()->NextRetryAttempt();
   EXPECT_FALSE(retry_time.is_null());
   EXPECT_GE((retry_time - connect_time).InMilliseconds(),
             CalculateBackoff(kNumAttempts));
 
+  // There should be one failed client event for each failed connection, but the
+  // most recent failure won't be added until the next connect attempt.
+  const auto* client_events = factory()->GetClientEventsForTest();
+  ASSERT_EQ(kNumAttempts - 1, client_events->size());
+
+  for (const auto client_event : *client_events) {
+    EXPECT_EQ(mcs_proto::ClientEvent::FAILED_CONNECTION, client_event.type());
+    EXPECT_EQ(net::ERR_CONNECTION_FAILED, client_event.error_code());
+  }
+
   factory()->SetConnectResult(net::OK);
   WaitForConnections();
   EXPECT_TRUE(factory()->NextRetryAttempt().is_null());
   EXPECT_TRUE(factory()->IsEndpointReachable());
   EXPECT_TRUE(connected_server().is_valid());
+
+  // Old client events should have been reset after the successful connection.
+  client_events = factory()->GetClientEventsForTest();
+  ASSERT_EQ(0, client_events->size());
 }
 
 // Network change events should trigger canary connections.
 TEST_F(ConnectionFactoryImplTest, FailThenNetworkChangeEvent) {
   factory()->SetConnectResult(net::ERR_CONNECTION_FAILED);
   factory()->Connect();
   WaitForConnections();
   base::TimeTicks initial_backoff = factory()->NextRetryAttempt();
   EXPECT_FALSE(initial_backoff.is_null());
 
@@ skipping 176 matching lines @@
 
   // Now trigger force a re-connection.
   factory()->SetConnectResult(net::OK);
   factory()->Connect();
   WaitForConnections();
 
   // Re-connection should succeed.
   EXPECT_TRUE(factory()->IsEndpointReachable());
 }
 
+TEST_F(ConnectionFactoryImplTest, MultipleFailuresWrapClientEvents) {
+  const int kNumAttempts = 50;
+  factory()->SetMultipleConnectResults(net::ERR_CONNECTION_FAILED,
+                                       kNumAttempts);
+
+  factory()->Connect();
+  WaitForConnections();
+
+  // There should be one failed client event for each failed connection, but
+  // there is a maximum cap of kMaxClientEvents, which is 30.
+  const auto* client_events = factory()->GetClientEventsForTest();
+  ASSERT_EQ(30, client_events->size());
+
+  for (const auto client_event : *client_events) {
+    EXPECT_EQ(mcs_proto::ClientEvent::FAILED_CONNECTION, client_event.type());
+    EXPECT_EQ(net::ERR_CONNECTION_FAILED, client_event.error_code());
+  }
+
+  factory()->SetConnectResult(net::OK);
+  WaitForConnections();
+  EXPECT_TRUE(factory()->IsEndpointReachable());
+  EXPECT_TRUE(connected_server().is_valid());
+
+  // Old client events should have been reset after the successful connection.
+  client_events = factory()->GetClientEventsForTest();
+  ASSERT_EQ(0, client_events->size());
+}
+
 }  // namespace gcm