[GCM] Suppress connection attempts when there is no valid connection.

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 "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "google_apis/gcm/engine/connection_handler_impl.h"
@@ skipping 39 matching lines @@
   : mcs_endpoints_(mcs_endpoints),
     next_endpoint_(0),
     last_successful_endpoint_(0),
     backoff_policy_(backoff_policy),
     network_session_(network_session),
     bound_net_log_(
         net::BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
     pac_request_(NULL),
     connecting_(false),
     waiting_for_backoff_(false),
+    waiting_for_network_change_(false),
     logging_in_(false),
     recorder_(recorder),
     listener_(NULL),
     weak_ptr_factory_(this) {
   DCHECK_GE(mcs_endpoints_.size(), 1U);
 }
 
 ConnectionFactoryImpl::~ConnectionFactoryImpl() {
-  net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
-  net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
+  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   if (pac_request_) {
     network_session_->proxy_service()->CancelPacRequest(pac_request_);
     pac_request_ = NULL;
   }
 }
 
 void ConnectionFactoryImpl::Initialize(
     const BuildLoginRequestCallback& request_builder,
     const ConnectionHandler::ProtoReceivedCallback& read_callback,
     const ConnectionHandler::ProtoSentCallback& write_callback) {
   DCHECK(!connection_handler_);
 
   previous_backoff_ = CreateBackoffEntry(&backoff_policy_);
   backoff_entry_ = CreateBackoffEntry(&backoff_policy_);
   request_builder_ = request_builder;
 
-  net::NetworkChangeNotifier::AddIPAddressObserver(this);
-  net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
+  waiting_for_network_change_ = net::NetworkChangeNotifier::IsOffline();
   connection_handler_ = CreateConnectionHandler(
       base::TimeDelta::FromMilliseconds(kReadTimeoutMs),
       read_callback,
       write_callback,
       base::Bind(&ConnectionFactoryImpl::ConnectionHandlerCallback,
                  weak_ptr_factory_.GetWeakPtr())).Pass();
 }
 
 ConnectionHandler* ConnectionFactoryImpl::GetConnectionHandler() const {
   return connection_handler_.get();
@@ skipping 45 matching lines @@
 
 std::string ConnectionFactoryImpl::GetConnectionStateString() const {
   if (IsEndpointReachable())
     return "CONNECTED";
   if (logging_in_)
     return "LOGGING IN";
   if (connecting_)
     return "CONNECTING";
   if (waiting_for_backoff_)
     return "WAITING FOR BACKOFF";
+  if (waiting_for_network_change_)
+    return "WAITING FOR NETWORK CHANGE";
   return "NOT CONNECTED";
 }
 
 void ConnectionFactoryImpl::SignalConnectionReset(
     ConnectionResetReason reason) {
   // A failure can trigger multiple resets, so no need to do anything if a
   // connection is already in progress.
   if (connecting_) {
     DVLOG(1) << "Connection in progress, ignoring reset.";
     return;
@@ skipping 12 matching lines @@
                                base::TimeDelta::FromSeconds(1),
                                base::TimeDelta::FromHours(24),
                                50);
     // |last_login_time_| will be reset below, before attempting the new
     // connection.
   }
 
   CloseSocket();
   DCHECK(!IsEndpointReachable());
 
+  if (waiting_for_network_change_)
+    return;
+
   // 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.
   if (waiting_for_backoff_ && reason != NETWORK_CHANGE) {
     DVLOG(1) << "Backoff expiration pending, ignoring reset.";
     return;
   }
 
   if (logging_in_) {
     // Failures prior to login completion just reuse the existing backoff entry.
     logging_in_ = false;
     backoff_entry_->InformOfRequest(false);
   } else if (reason == LOGIN_FAILURE ||
              ShouldRestorePreviousBackoff(last_login_time_, NowTicks())) {
     // Failures due to login, or within the reset window of a login, restore
     // the backoff entry that was saved off at login completion time.
     backoff_entry_.swap(previous_backoff_);
     backoff_entry_->InformOfRequest(false);
   } else if (reason == NETWORK_CHANGE) {
     ConnectImpl();  // Canary attempts bypass backoff without resetting it.
     return;
   } else {
     // We shouldn't be in backoff in thise case.
     DCHECK_EQ(0, backoff_entry_->failure_count());
   }
-  DCHECK(!connecting_);
-  DCHECK(!waiting_for_backoff_);
 
   // At this point the last login time has been consumed or deemed irrelevant,
   // reset it.
   last_login_time_ = base::TimeTicks();
 
   Connect();
 }
 
 void ConnectionFactoryImpl::SetConnectionListener(
     ConnectionListener* listener) {
   listener_ = listener;
 }
 
 base::TimeTicks ConnectionFactoryImpl::NextRetryAttempt() const {
   if (!backoff_entry_)
     return base::TimeTicks();
   return backoff_entry_->GetReleaseTime();
 }
 
-void ConnectionFactoryImpl::OnConnectionTypeChanged(
+void ConnectionFactoryImpl::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
-  if (type == net::NetworkChangeNotifier::CONNECTION_NONE)
+  if (type == net::NetworkChangeNotifier::CONNECTION_NONE) {
+    DVLOG(1) << "Network lost, resettion connection.";
+    waiting_for_network_change_ = true;
+
+    // Will do nothing due to |waiting_for_network_change_ == true|.
+    SignalConnectionReset(NETWORK_CHANGE);
     return;
+  }
 
   DVLOG(1) << "Connection type changed to " << type << ", reconnecting.";
-
-  // The connection may have been silently dropped, attempt to reconnect.
+  waiting_for_network_change_ = false;
   SignalConnectionReset(NETWORK_CHANGE);
 }
 
-void ConnectionFactoryImpl::OnIPAddressChanged() {
-  DVLOG(1) << "IP Address changed, reconnecting.";
-
-  // The connection may have been silently dropped, attempt to reconnect.
-  SignalConnectionReset(NETWORK_CHANGE);
-}
-
 GURL ConnectionFactoryImpl::GetCurrentEndpoint() const {
   // Note that IsEndpointReachable() returns false anytime connecting_ is true,
   // so while connecting this always uses |next_endpoint_|.
   if (IsEndpointReachable())
     return mcs_endpoints_[last_successful_endpoint_];
   return mcs_endpoints_[next_endpoint_];
 }
 
 net::IPEndPoint ConnectionFactoryImpl::GetPeerIP() {
   if (!socket_handle_.socket())
     return net::IPEndPoint();
 
   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() {
   DCHECK(!IsEndpointReachable());
   DCHECK(!socket_handle_.socket());
 
+  if (waiting_for_network_change_)
+    return;
+
   connecting_ = true;
   GURL current_endpoint = GetCurrentEndpoint();
   recorder_->RecordConnectionInitiated(current_endpoint.host());
   int status = network_session_->proxy_service()->ResolveProxy(
       current_endpoint,
       &proxy_info_,
       base::Bind(&ConnectionFactoryImpl::OnProxyResolveDone,
                  weak_ptr_factory_.GetWeakPtr()),
       &pac_request_,
       bound_net_log_);
@@ skipping 245 matching lines @@
   // the destroyed socket.
   if (connection_handler_)
     connection_handler_->Reset();
 
   if (socket_handle_.socket() && socket_handle_.socket()->IsConnected())
     socket_handle_.socket()->Disconnect();
   socket_handle_.Reset();
 }
 
 }  // namespace gcm