[GCM] Add ConnectionListener support, and hook up to debug page

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 "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 236 matching lines @@
                    BuildLoginRequest(0, 0, "").PassAs<
                        const google::protobuf::MessageLite>()));
   }
 }
 
 void TestConnectionFactoryImpl::SetDelayLogin(bool delay_login) {
   delay_login_ = delay_login;
   fake_handler_->set_fail_login(delay_login_);
 }
 
-class ConnectionFactoryImplTest : public testing::Test {
+}  // namespace
+
+class ConnectionFactoryImplTest
+    : public testing::Test,
+      public ConnectionFactory::ConnectionListener {
  public:
   ConnectionFactoryImplTest();
   virtual ~ConnectionFactoryImplTest();
 
   TestConnectionFactoryImpl* factory() { return &factory_; }
+  GURL& connected_server() { return connected_server_; }
 
   void WaitForConnections();
 
+  // ConnectionFactory::ConnectionListener
+  virtual void OnConnected(const GURL& current_server,
+                           const net::IPEndPoint& ip_endpoint) OVERRIDE;
+  virtual void OnDisconnected() OVERRIDE;
+
  private:
   void ConnectionsComplete();
 
   TestConnectionFactoryImpl factory_;
   base::MessageLoop message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
+
+  GURL connected_server_;
 };
 
 ConnectionFactoryImplTest::ConnectionFactoryImplTest()
    : factory_(base::Bind(&ConnectionFactoryImplTest::ConnectionsComplete,
                          base::Unretained(this))),
      run_loop_(new base::RunLoop()) {
+  factory()->SetConnectionListener(this);
   factory()->Initialize(
       ConnectionFactory::BuildLoginRequestCallback(),
       ConnectionHandler::ProtoReceivedCallback(),
       ConnectionHandler::ProtoSentCallback());
 }
 ConnectionFactoryImplTest::~ConnectionFactoryImplTest() {}
 
 void ConnectionFactoryImplTest::WaitForConnections() {
   run_loop_->Run();
   run_loop_.reset(new base::RunLoop());
 }
 
 void ConnectionFactoryImplTest::ConnectionsComplete() {
   if (!run_loop_)
     return;
   run_loop_->Quit();
 }
 
+void ConnectionFactoryImplTest::OnConnected(
+    const GURL& current_server,
+    const net::IPEndPoint& ip_endpoint) {
+  connected_server_ = current_server;
+}
+
+void ConnectionFactoryImplTest::OnDisconnected() {
+  connected_server_ = GURL();
+}
+
 // Verify building a connection handler works.
 TEST_F(ConnectionFactoryImplTest, Initialize) {
   ConnectionHandler* handler = factory()->GetConnectionHandler();
   ASSERT_TRUE(handler);
   EXPECT_FALSE(factory()->IsEndpointReachable());
+  EXPECT_FALSE(connected_server().is_valid());
 }
 
 // An initial successful connection should not result in backoff.
 TEST_F(ConnectionFactoryImplTest, ConnectSuccess) {
   factory()->SetConnectResult(net::OK);
   factory()->Connect();
   EXPECT_TRUE(factory()->NextRetryAttempt().is_null());
   EXPECT_EQ(factory()->GetCurrentEndpoint(), BuildEndpoints()[0]);
   EXPECT_TRUE(factory()->IsEndpointReachable());
+  EXPECT_TRUE(connected_server().is_valid());
 }
 
 // A connection failure should result in backoff, and attempting the fallback
 // endpoint next.
 TEST_F(ConnectionFactoryImplTest, ConnectFail) {
   factory()->SetConnectResult(net::ERR_CONNECTION_FAILED);
   factory()->Connect();
   EXPECT_FALSE(factory()->NextRetryAttempt().is_null());
   EXPECT_EQ(factory()->GetCurrentEndpoint(), BuildEndpoints()[1]);
   EXPECT_FALSE(factory()->IsEndpointReachable());
+  EXPECT_FALSE(connected_server().is_valid());
 }
 
 // A connection success after a failure should reset backoff.
 TEST_F(ConnectionFactoryImplTest, FailThenSucceed) {
   factory()->SetConnectResult(net::ERR_CONNECTION_FAILED);
   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(1));
   factory()->SetConnectResult(net::OK);
   WaitForConnections();
   EXPECT_TRUE(factory()->NextRetryAttempt().is_null());
   EXPECT_TRUE(factory()->IsEndpointReachable());
+  EXPECT_TRUE(connected_server().is_valid());
 }
 
 // Multiple connection failures should retry with an exponentially increasing
 // backoff, then reset on success.
 TEST_F(ConnectionFactoryImplTest, MultipleFailuresThenSucceed) {
   const int kNumAttempts = 5;
   factory()->SetMultipleConnectResults(net::ERR_CONNECTION_FAILED,
                                        kNumAttempts);
 
   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));
 
   factory()->SetConnectResult(net::OK);
   WaitForConnections();
   EXPECT_TRUE(factory()->NextRetryAttempt().is_null());
   EXPECT_TRUE(factory()->IsEndpointReachable());
+  EXPECT_TRUE(connected_server().is_valid());
 }
 
 // IP events should trigger canary connections.
 TEST_F(ConnectionFactoryImplTest, FailThenIPEvent) {
   factory()->SetConnectResult(net::ERR_CONNECTION_FAILED);
   factory()->Connect();
   WaitForConnections();
   base::TimeTicks initial_backoff = factory()->NextRetryAttempt();
   EXPECT_FALSE(initial_backoff.is_null());
 
@@ skipping 33 matching lines @@
   factory()->Connect();
   WaitForConnections();
   base::TimeTicks initial_backoff = factory()->NextRetryAttempt();
   EXPECT_FALSE(initial_backoff.is_null());
 
   factory()->SetConnectResult(net::OK);
   factory()->OnConnectionTypeChanged(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   WaitForConnections();
   EXPECT_TRUE(factory()->IsEndpointReachable());
+  EXPECT_TRUE(connected_server().is_valid());
 
   factory()->SetConnectResult(net::OK);
   factory()->SignalConnectionReset(ConnectionFactory::SOCKET_FAILURE);
   EXPECT_FALSE(factory()->IsEndpointReachable());
+  EXPECT_FALSE(connected_server().is_valid());
   WaitForConnections();
   EXPECT_TRUE(factory()->IsEndpointReachable());
+  EXPECT_TRUE(connected_server().is_valid());
 }
 
 // Verify that if a canary connects, but hasn't finished the handshake, a
 // pending backoff attempt doesn't interrupt the connection.
 TEST_F(ConnectionFactoryImplTest, CanarySucceedsRetryDuringLogin) {
   factory()->SetConnectResult(net::ERR_CONNECTION_FAILED);
   factory()->Connect();
   WaitForConnections();
   base::TimeTicks initial_backoff = factory()->NextRetryAttempt();
   EXPECT_FALSE(initial_backoff.is_null());
@@ skipping 52 matching lines @@
   base::TimeTicks retry_time = factory()->NextRetryAttempt();
   EXPECT_FALSE(retry_time.is_null());
 
   factory()->SetConnectResult(net::OK);
   connect_time = factory()->tick_clock()->NowTicks();
   WaitForConnections();
   EXPECT_TRUE(factory()->NextRetryAttempt().is_null());
 
   factory()->SignalConnectionReset(ConnectionFactory::SOCKET_FAILURE);
   EXPECT_FALSE(factory()->IsEndpointReachable());
+  EXPECT_FALSE(connected_server().is_valid());
   EXPECT_NE(retry_time, factory()->NextRetryAttempt());
   retry_time = factory()->NextRetryAttempt();
   EXPECT_FALSE(retry_time.is_null());
   EXPECT_GE((retry_time - connect_time).InMilliseconds(),
             CalculateBackoff(2));
 
   factory()->SetConnectResult(net::OK);
   connect_time = factory()->tick_clock()->NowTicks();
   factory()->tick_clock()->Advance(
       factory()->NextRetryAttempt() - connect_time);
   WaitForConnections();
   EXPECT_TRUE(factory()->NextRetryAttempt().is_null());
   EXPECT_TRUE(factory()->IsEndpointReachable());
+  EXPECT_TRUE(connected_server().is_valid());
 
   factory()->SignalConnectionReset(ConnectionFactory::SOCKET_FAILURE);
   EXPECT_NE(retry_time, factory()->NextRetryAttempt());
   retry_time = factory()->NextRetryAttempt();
   EXPECT_FALSE(retry_time.is_null());
   EXPECT_GE((retry_time - connect_time).InMilliseconds(),
             CalculateBackoff(3));
   EXPECT_FALSE(factory()->IsEndpointReachable());
+  EXPECT_FALSE(connected_server().is_valid());
 }
 
-}  // namespace
 }  // namespace gcm