Made CacheInvalidationPacketHandler aware of XmppClient state changes.

chrome/browser/sync/notifier/cache_invalidation_packet_handler.cc

 // Copyright (c) 2010 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 "chrome/browser/sync/notifier/cache_invalidation_packet_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/callback.h"
@@ skipping 184 matching lines @@
 
 CacheInvalidationPacketHandler::CacheInvalidationPacketHandler(
     buzz::XmppClient* xmpp_client,
     invalidation::InvalidationClient* invalidation_client)
     : xmpp_client_(xmpp_client),
       invalidation_client_(invalidation_client),
       seq_(0),
       sid_(MakeSid()) {
   CHECK(xmpp_client_);
   CHECK(invalidation_client_);
+  if (xmpp_client_->GetState() != buzz::XmppEngine::STATE_OPEN) {
+    LOG(DFATAL) << "non-open xmpp_client_ passed to "
+                << "CacheInvalidationPacketHandler";
+    return;
+  }
+  xmpp_client_->SignalStateChange.connect(
+      this, &CacheInvalidationPacketHandler::OnClientStateChange);
   invalidation::NetworkEndpoint* network_endpoint =
       invalidation_client_->network_endpoint();
   CHECK(network_endpoint);
   network_endpoint->RegisterOutboundListener(
       invalidation::NewPermanentCallback(
           this,
           &CacheInvalidationPacketHandler::HandleOutboundPacket));
   // Owned by xmpp_client.
   CacheInvalidationListenTask* listen_task =
       new CacheInvalidationListenTask(
           xmpp_client, NewCallback(
               this, &CacheInvalidationPacketHandler::HandleInboundPacket));
   listen_task->Start();
 }
 
 CacheInvalidationPacketHandler::~CacheInvalidationPacketHandler() {
   invalidation::NetworkEndpoint* network_endpoint =
       invalidation_client_->network_endpoint();
   CHECK(network_endpoint);
   network_endpoint->RegisterOutboundListener(NULL);
 }
 
 void CacheInvalidationPacketHandler::HandleOutboundPacket(
     invalidation::NetworkEndpoint* const& network_endpoint) {
   CHECK_EQ(network_endpoint, invalidation_client_->network_endpoint());
+  if (!xmpp_client_) {
+    LOG(DFATAL) << "HandleOutboundPacket() called with NULL xmpp_client_";
+    return;
+  }
   invalidation::string message;
   network_endpoint->TakeOutboundMessage(&message);
   std::string encoded_message;
   if (!base::Base64Encode(message, &encoded_message)) {
     LOG(ERROR) << "Could not base64-encode message to send: "
                << message;
     return;
   }
   // Owned by xmpp_client.
   CacheInvalidationSendMessageTask* send_message_task =
@@ skipping 11 matching lines @@
       invalidation_client_->network_endpoint();
   std::string decoded_message;
   if (!base::Base64Decode(packet, &decoded_message)) {
     LOG(ERROR) << "Could not base64-decode received message: "
                << packet;
     return;
   }
   network_endpoint->HandleInboundMessage(decoded_message);
 }
 
+void CacheInvalidationPacketHandler::OnClientStateChange(
+    buzz::XmppEngine::State state) {
+  switch (state) {
+    case buzz::XmppEngine::STATE_OPEN:
+      LOG(INFO) << "redundant STATE_OPEN message received";
+      break;
+    case buzz::XmppEngine::STATE_CLOSED:
+      LOG(INFO) << "xmpp_client_ closed -- setting to NULL";
+      xmpp_client_->SignalStateChange.disconnect(this);
+      xmpp_client_ = NULL;
+      break;
+    default:
+      LOG(INFO) << "xmpp_client_ state changed to " << state;
+      break;
+  }
+}
+
 }  // namespace sync_notifier