Refactor SignalStrategy so that it can be reused for multiple connections.

Also updated SessionManager implementation so that session managers can
be created before signaling is connected.

BUG=107276

Review URL: http://codereview.chromium.org/9005034

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@116192 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 169 insertions, 112 deletions

diff --git a/remoting/jingle_glue/fake_signal_strategy.cc b/remoting/jingle_glue/fake_signal_strategy.cc
index 4cbfd23..657b0ad 100644
--- a/remoting/jingle_glue/fake_signal_strategy.cc
+++ b/remoting/jingle_glue/fake_signal_strategy.cc
@@ -34,33 +34,37 @@ FakeSignalStrategy::~FakeSignalStrategy() {
     delete pending_messages_.front();
     pending_messages_.pop();
   }
-  DCHECK(listeners_.empty());
 }
 
-void FakeSignalStrategy::Init(StatusObserver* observer) {
-  observer->OnStateChange(StatusObserver::START);
-  observer->OnStateChange(StatusObserver::CONNECTING);
-  observer->OnJidChange(jid_);
-  observer->OnStateChange(StatusObserver::CONNECTED);
+void FakeSignalStrategy::Connect() {
+  DCHECK(CalledOnValidThread());
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnSignalStrategyStateChange(CONNECTED));
+}
+
+void FakeSignalStrategy::Disconnect() {
+  DCHECK(CalledOnValidThread());
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnSignalStrategyStateChange(DISCONNECTED));
+}
+
+SignalStrategy::State FakeSignalStrategy::GetState() const {
+  return CONNECTED;
 }
 
-void FakeSignalStrategy::Close() {
+std::string FakeSignalStrategy::GetLocalJid() const {
   DCHECK(CalledOnValidThread());
+  return jid_;
 }
 
 void FakeSignalStrategy::AddListener(Listener* listener) {
   DCHECK(CalledOnValidThread());
-  DCHECK(std::find(listeners_.begin(), listeners_.end(), listener) ==
-         listeners_.end());
-  listeners_.push_back(listener);
+  listeners_.AddObserver(listener);
 }
 
 void FakeSignalStrategy::RemoveListener(Listener* listener) {
   DCHECK(CalledOnValidThread());
-  std::vector<Listener*>::iterator it =
-      std::find(listeners_.begin(), listeners_.end(), listener);
-  CHECK(it != listeners_.end());
-  listeners_.erase(it);
+  listeners_.RemoveObserver(listener);
 }
 
 bool FakeSignalStrategy::SendStanza(buzz::XmlElement* stanza) {
@@ -100,9 +104,10 @@ void FakeSignalStrategy::DeliverIncomingMessages() {
       return;
     }
 
-    for (std::vector<Listener*>::iterator it = listeners_.begin();
-         it != listeners_.end(); ++it) {
-      if ((*it)->OnIncomingStanza(stanza))
+    ObserverListBase<Listener>::Iterator it(listeners_);
+    Listener* listener;
+    while ((listener = it.GetNext()) != NULL) {
+      if (listener->OnSignalStrategyIncomingStanza(stanza))
         break;
     }
 
diff --git a/remoting/jingle_glue/fake_signal_strategy.h b/remoting/jingle_glue/fake_signal_strategy.h
index e14931f..db9cd0a 100644
--- a/remoting/jingle_glue/fake_signal_strategy.h
+++ b/remoting/jingle_glue/fake_signal_strategy.h
@@ -8,6 +8,7 @@
 #include <queue>
 #include <string>
 
+#include "base/observer_list.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "remoting/jingle_glue/iq_sender.h"
@@ -24,8 +25,10 @@ class FakeSignalStrategy : public SignalStrategy,
   virtual ~FakeSignalStrategy();
 
   // SignalStrategy interface.
-  virtual void Init(StatusObserver* observer) OVERRIDE;
-  virtual void Close() OVERRIDE;
+  virtual void Connect() OVERRIDE;
+  virtual void Disconnect() OVERRIDE;
+  virtual State GetState() const OVERRIDE;
+  virtual std::string GetLocalJid() const OVERRIDE;
   virtual void AddListener(Listener* listener) OVERRIDE;
   virtual void RemoveListener(Listener* listener) OVERRIDE;
   virtual bool SendStanza(buzz::XmlElement* stanza) OVERRIDE;
@@ -39,7 +42,7 @@ class FakeSignalStrategy : public SignalStrategy,
 
   std::string jid_;
   FakeSignalStrategy* peer_;
-  std::vector<Listener*> listeners_;
+  ObserverList<Listener, true> listeners_;
 
   int last_id_;
 
diff --git a/remoting/jingle_glue/iq_sender.cc b/remoting/jingle_glue/iq_sender.cc
index e0e1e5b..d22e0f8 100644
--- a/remoting/jingle_glue/iq_sender.cc
+++ b/remoting/jingle_glue/iq_sender.cc
@@ -66,7 +66,10 @@ void IqSender::RemoveRequest(IqRequest* request) {
   }
 }
 
-bool IqSender::OnIncomingStanza(const buzz::XmlElement* stanza) {
+void IqSender::OnSignalStrategyStateChange(SignalStrategy::State state) {
+}
+
+bool IqSender::OnSignalStrategyIncomingStanza(const buzz::XmlElement* stanza) {
   if (stanza->Name() != buzz::QN_IQ) {
     LOG(WARNING) << "Received unexpected non-IQ packet " << stanza->Str();
     return false;
diff --git a/remoting/jingle_glue/iq_sender.h b/remoting/jingle_glue/iq_sender.h
index 2696b80..68871a4 100644
--- a/remoting/jingle_glue/iq_sender.h
+++ b/remoting/jingle_glue/iq_sender.h
@@ -48,7 +48,10 @@ class IqSender : public SignalStrategy::Listener {
                     const ReplyCallback& callback) WARN_UNUSED_RESULT;
 
   // SignalStrategy::Listener implementation.
-  virtual bool OnIncomingStanza(const buzz::XmlElement* stanza) OVERRIDE;
+  virtual void OnSignalStrategyStateChange(
+      SignalStrategy::State state) OVERRIDE;
+  virtual bool OnSignalStrategyIncomingStanza(
+      const buzz::XmlElement* stanza) OVERRIDE;
 
  private:
   typedef std::map<std::string, IqRequest*> IqRequestMap;
diff --git a/remoting/jingle_glue/iq_sender_unittest.cc b/remoting/jingle_glue/iq_sender_unittest.cc
index f9dc8af..70bd4ec 100644
--- a/remoting/jingle_glue/iq_sender_unittest.cc
+++ b/remoting/jingle_glue/iq_sender_unittest.cc
@@ -86,7 +86,7 @@ TEST_F(IqSenderTest, SendIq) {
   response->AddElement(result);
 
   EXPECT_CALL(callback_, OnReply(response.get()));
-  EXPECT_TRUE(sender_->OnIncomingStanza(response.get()));
+  EXPECT_TRUE(sender_->OnSignalStrategyIncomingStanza(response.get()));
 }
 
 }  // namespace remoting
diff --git a/remoting/jingle_glue/javascript_signal_strategy.cc b/remoting/jingle_glue/javascript_signal_strategy.cc
index a26a385..15a5d89 100644
--- a/remoting/jingle_glue/javascript_signal_strategy.cc
+++ b/remoting/jingle_glue/javascript_signal_strategy.cc
@@ -13,59 +13,57 @@
 
 namespace remoting {
 
-JavascriptSignalStrategy::JavascriptSignalStrategy(const std::string& your_jid)
-    : your_jid_(your_jid),
+JavascriptSignalStrategy::JavascriptSignalStrategy(const std::string& local_jid)
+    : local_jid_(local_jid),
       last_id_(0) {
 }
 
 JavascriptSignalStrategy::~JavascriptSignalStrategy() {
-  DCHECK(listeners_.empty());
-  Close();
+  DCHECK_EQ(listeners_.size(), 0U);
+  Disconnect();
 }
 
 void JavascriptSignalStrategy::AttachXmppProxy(
     scoped_refptr<XmppProxy> xmpp_proxy) {
   DCHECK(CalledOnValidThread());
   xmpp_proxy_ = xmpp_proxy;
-  xmpp_proxy_->AttachCallback(AsWeakPtr());
 }
 
-void JavascriptSignalStrategy::Init(StatusObserver* observer) {
+void JavascriptSignalStrategy::Connect() {
   DCHECK(CalledOnValidThread());
 
-  // Blast through each state since for a JavascriptSignalStrategy, we're
-  // already connected.
-  //
-  // TODO(ajwong): Clarify the status API contract to see if we have to actually
-  // walk through each state.
-  observer->OnStateChange(StatusObserver::START);
-  observer->OnStateChange(StatusObserver::CONNECTING);
-  observer->OnJidChange(your_jid_);
-  observer->OnStateChange(StatusObserver::CONNECTED);
+  xmpp_proxy_->AttachCallback(AsWeakPtr());
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnSignalStrategyStateChange(CONNECTED));
 }
 
-void JavascriptSignalStrategy::Close() {
+void JavascriptSignalStrategy::Disconnect() {
   DCHECK(CalledOnValidThread());
 
-  if (xmpp_proxy_) {
+  if (xmpp_proxy_)
     xmpp_proxy_->DetachCallback();
-    xmpp_proxy_ = NULL;
-  }
+  FOR_EACH_OBSERVER(Listener, listeners_,
+                    OnSignalStrategyStateChange(DISCONNECTED));
+}
+
+SignalStrategy::State JavascriptSignalStrategy::GetState() const {
+  // TODO(sergeyu): Extend XmppProxy to provide status of the
+  // connection.
+  return CONNECTED;
+}
+
+std::string JavascriptSignalStrategy::GetLocalJid() const {
+  return local_jid_;
 }
 
 void JavascriptSignalStrategy::AddListener(Listener* listener) {
   DCHECK(CalledOnValidThread());
-  DCHECK(std::find(listeners_.begin(), listeners_.end(), listener) ==
-         listeners_.end());
-  listeners_.push_back(listener);
+  listeners_.AddObserver(listener);
 }
 
 void JavascriptSignalStrategy::RemoveListener(Listener* listener) {
   DCHECK(CalledOnValidThread());
-  std::vector<Listener*>::iterator it =
-      std::find(listeners_.begin(), listeners_.end(), listener);
-  CHECK(it != listeners_.end());
-  listeners_.erase(it);
+  listeners_.RemoveObserver(listener);
 }
 
 bool JavascriptSignalStrategy::SendStanza(buzz::XmlElement* stanza) {
@@ -89,9 +87,10 @@ void JavascriptSignalStrategy::OnIq(const std::string& stanza_str) {
     return;
   }
 
-  for (std::vector<Listener*>::iterator it = listeners_.begin();
-       it != listeners_.end(); ++it) {
-    if ((*it)->OnIncomingStanza(stanza.get()))
+  ObserverListBase<Listener>::Iterator it(listeners_);
+  Listener* listener;
+  while ((listener = it.GetNext()) != NULL) {
+    if (listener->OnSignalStrategyIncomingStanza(stanza.get()))
       break;
   }
 }
diff --git a/remoting/jingle_glue/javascript_signal_strategy.h b/remoting/jingle_glue/javascript_signal_strategy.h
index 923dd27..69ae52d 100644
--- a/remoting/jingle_glue/javascript_signal_strategy.h
+++ b/remoting/jingle_glue/javascript_signal_strategy.h
@@ -12,6 +12,7 @@
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/observer_list.h"
 #include "base/threading/non_thread_safe.h"
 #include "remoting/jingle_glue/xmpp_proxy.h"
 
@@ -23,14 +24,16 @@ class JavascriptSignalStrategy : public SignalStrategy,
                                  public XmppProxy::ResponseCallback,
                                  public base::NonThreadSafe {
  public:
-  explicit JavascriptSignalStrategy(const std::string& your_jid);
+  explicit JavascriptSignalStrategy(const std::string& local_jid);
   virtual ~JavascriptSignalStrategy();
 
   void AttachXmppProxy(scoped_refptr<XmppProxy> xmpp_proxy);
 
   // SignalStrategy interface.
-  virtual void Init(StatusObserver* observer) OVERRIDE;
-  virtual void Close() OVERRIDE;
+  virtual void Connect() OVERRIDE;
+  virtual void Disconnect() OVERRIDE;
+  virtual State GetState() const OVERRIDE;
+  virtual std::string GetLocalJid() const OVERRIDE;
   virtual void AddListener(Listener* listener) OVERRIDE;
   virtual void RemoveListener(Listener* listener) OVERRIDE;
   virtual bool SendStanza(buzz::XmlElement* stanza) OVERRIDE;
@@ -40,10 +43,10 @@ class JavascriptSignalStrategy : public SignalStrategy,
   virtual void OnIq(const std::string& stanza) OVERRIDE;
 
  private:
-  std::string your_jid_;
+  std::string local_jid_;
   scoped_refptr<XmppProxy> xmpp_proxy_;
 
-  std::vector<Listener*> listeners_;
+  ObserverList<Listener> listeners_;
 
   int last_id_;
 
diff --git a/remoting/jingle_glue/jingle_signaling_connector.cc b/remoting/jingle_glue/jingle_signaling_connector.cc
index 2cfe3da..913633a 100644
--- a/remoting/jingle_glue/jingle_signaling_connector.cc
+++ b/remoting/jingle_glue/jingle_signaling_connector.cc
@@ -48,7 +48,11 @@ JingleSignalingConnector::~JingleSignalingConnector() {
                                        pending_requests_.end());
 }
 
-bool JingleSignalingConnector::OnIncomingStanza(
+void JingleSignalingConnector::OnSignalStrategyStateChange(
+    SignalStrategy::State state) {
+}
+
+bool JingleSignalingConnector::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   if (session_manager_->IsSessionMessage(stanza)) {
     session_manager_->OnIncomingMessage(stanza);
diff --git a/remoting/jingle_glue/jingle_signaling_connector.h b/remoting/jingle_glue/jingle_signaling_connector.h
index 2aa41bc..f26fb32 100644
--- a/remoting/jingle_glue/jingle_signaling_connector.h
+++ b/remoting/jingle_glue/jingle_signaling_connector.h
@@ -41,7 +41,10 @@ class JingleSignalingConnector : public SignalStrategy::Listener,
   virtual ~JingleSignalingConnector();
 
   // SignalStrategy::Listener interface.
-  virtual bool OnIncomingStanza(const buzz::XmlElement* stanza) OVERRIDE;
+  virtual void OnSignalStrategyStateChange(
+      SignalStrategy::State state) OVERRIDE;
+  virtual bool OnSignalStrategyIncomingStanza(
+      const buzz::XmlElement* stanza) OVERRIDE;
 
  private:
   typedef std::map<std::string, buzz::XmlElement*> IqRequestsMap;
diff --git a/remoting/jingle_glue/mock_objects.h b/remoting/jingle_glue/mock_objects.h
index aad9697..61bc2d3 100644
--- a/remoting/jingle_glue/mock_objects.h
+++ b/remoting/jingle_glue/mock_objects.h
@@ -14,13 +14,14 @@ class MockSignalStrategy : public SignalStrategy {
   MockSignalStrategy();
   virtual ~MockSignalStrategy();
 
-  MOCK_METHOD1(Init, void(StatusObserver*));
-  MOCK_METHOD0(Close, void());
+  MOCK_METHOD0(Connect, void());
+  MOCK_METHOD0(Disconnect, void());
+  MOCK_CONST_METHOD0(GetState, State());
+  MOCK_CONST_METHOD0(GetLocalJid, std::string());
   MOCK_METHOD1(AddListener, void(Listener* listener));
   MOCK_METHOD1(RemoveListener, void(Listener* listener));
   MOCK_METHOD1(SendStanza, bool(buzz::XmlElement* stanza));
   MOCK_METHOD0(GetNextId, std::string());
-  MOCK_METHOD0(CreateIqRequest, IqRequest*());
 };
 
 }  // namespace remoting
diff --git a/remoting/jingle_glue/signal_strategy.h b/remoting/jingle_glue/signal_strategy.h
index c4bfabe..a71e3c7 100644
--- a/remoting/jingle_glue/signal_strategy.h
+++ b/remoting/jingle_glue/signal_strategy.h
@@ -17,33 +17,55 @@ namespace remoting {
 
 class SignalStrategy {
  public:
-  class StatusObserver {
-   public:
-    enum State {
-      START,
-      CONNECTING,
-      CONNECTED,
-      CLOSED,
-    };
-
-    // Called when state of the connection is changed.
-    virtual void OnStateChange(State state) = 0;
-    virtual void OnJidChange(const std::string& full_jid) = 0;
+  enum State {
+    // Connection is being established.
+    CONNECTING,
+
+    // Signalling is connected.
+    CONNECTED,
+
+    // Connection is closed due to an error or because Disconnect()
+    // was called.
+    DISCONNECTED,
   };
 
+  // Callback interface for signaling event. Event handlers are not
+  // allowed to destroy SignalStrategy, but may add or remove other
+  // listeners.
   class Listener {
    public:
+    virtual ~Listener() {}
+
+    // Called after state of the connection has changed.
+    virtual void OnSignalStrategyStateChange(State state) {}
+
     // Must return true if the stanza was handled, false otherwise.
-    virtual bool OnIncomingStanza(const buzz::XmlElement* stanza) = 0;
+    virtual bool OnSignalStrategyIncomingStanza(
+        const buzz::XmlElement* stanza) { return false; }
   };
 
   SignalStrategy() {}
   virtual ~SignalStrategy() {}
-  virtual void Init(StatusObserver* observer) = 0;
-  virtual void Close() = 0;
+
+  // Starts connection attempt. If connection is currently active
+  // disconnects it and opens a new connection (implicit disconnect
+  // triggers CLOSED notification). Connection is finished
+  // asynchronously.
+  virtual void Connect() = 0;
+
+  // Disconnects current connection if connected. Triggers CLOSED
+  // notification.
+  virtual void Disconnect() = 0;
+
+  // Returns current state.
+  virtual State GetState() const = 0;
+
+  // Returns local JID or an empty string when not connected.
+  virtual std::string GetLocalJid() const = 0;
 
   // Add a |listener| that can listen to all incoming
-  // messages. Doesn't take ownership of the |listener|.
+  // messages. Doesn't take ownership of the |listener|. All listeners
+  // must be removed before this object is destroyed.
   virtual void AddListener(Listener* listener) = 0;
 
   // Remove a |listener| previously added with AddListener().
diff --git a/remoting/jingle_glue/xmpp_signal_strategy.cc b/remoting/jingle_glue/xmpp_signal_strategy.cc
index 26ea9ca..f367b65 100644
--- a/remoting/jingle_glue/xmpp_signal_strategy.cc
+++ b/remoting/jingle_glue/xmpp_signal_strategy.cc
@@ -23,20 +23,20 @@ XmppSignalStrategy::XmppSignalStrategy(JingleThread* jingle_thread,
      auth_token_(auth_token),
      auth_token_service_(auth_token_service),
      xmpp_client_(NULL),
-     observer_(NULL) {
+     state_(DISCONNECTED) {
 }
 
 XmppSignalStrategy::~XmppSignalStrategy() {
-  DCHECK(listeners_.empty());
-  Close();
+  DCHECK_EQ(listeners_.size(), 0U);
+  Disconnect();
 }
 
-void XmppSignalStrategy::Init(StatusObserver* observer) {
-  observer_ = observer;
-
-  buzz::Jid login_jid(username_);
+void XmppSignalStrategy::Connect() {
+  // Disconnect first if we are currently connected.
+  Disconnect();
 
   buzz::XmppClientSettings settings;
+  buzz::Jid login_jid(username_);
   settings.set_user(login_jid.node());
   settings.set_host(login_jid.domain());
   settings.set_resource("chromoting");
@@ -55,7 +55,7 @@ void XmppSignalStrategy::Init(StatusObserver* observer) {
   xmpp_client_->Start();
 }
 
-void XmppSignalStrategy::Close() {
+void XmppSignalStrategy::Disconnect() {
   if (xmpp_client_) {
     xmpp_client_->engine()->RemoveStanzaHandler(this);
 
@@ -67,17 +67,20 @@ void XmppSignalStrategy::Close() {
   }
 }
 
+SignalStrategy::State XmppSignalStrategy::GetState() const {
+  return state_;
+}
+
+std::string XmppSignalStrategy::GetLocalJid() const {
+  return xmpp_client_->jid().Str();
+}
+
 void XmppSignalStrategy::AddListener(Listener* listener) {
-  DCHECK(std::find(listeners_.begin(), listeners_.end(), listener) ==
-         listeners_.end());
-  listeners_.push_back(listener);
+  listeners_.AddObserver(listener);
 }
 
 void XmppSignalStrategy::RemoveListener(Listener* listener) {
-  std::vector<Listener*>::iterator it =
-      std::find(listeners_.begin(), listeners_.end(), listener);
-  CHECK(it != listeners_.end());
-  listeners_.erase(it);
+  listeners_.RemoveObserver(listener);
 }
 
 bool XmppSignalStrategy::SendStanza(buzz::XmlElement* stanza) {
@@ -102,36 +105,44 @@ std::string XmppSignalStrategy::GetNextId() {
 }
 
 bool XmppSignalStrategy::HandleStanza(const buzz::XmlElement* stanza) {
-  for (std::vector<Listener*>::iterator it = listeners_.begin();
-       it != listeners_.end(); ++it) {
-    if ((*it)->OnIncomingStanza(stanza))
-      return true;
+  ObserverListBase<Listener>::Iterator it(listeners_);
+  Listener* listener;
+  while ((listener = it.GetNext()) != NULL) {
+    if (listener->OnSignalStrategyIncomingStanza(stanza))
+      break;
   }
   return false;
 }
 
 void XmppSignalStrategy::OnConnectionStateChanged(
     buzz::XmppEngine::State state) {
+  State new_state;
+
   switch (state) {
     case buzz::XmppEngine::STATE_START:
-      observer_->OnStateChange(StatusObserver::START);
-      break;
+      return;
+
     case buzz::XmppEngine::STATE_OPENING:
-      observer_->OnStateChange(StatusObserver::CONNECTING);
+      new_state = CONNECTING;
       break;
     case buzz::XmppEngine::STATE_OPEN:
-      observer_->OnJidChange(xmpp_client_->jid().Str());
-      observer_->OnStateChange(StatusObserver::CONNECTED);
+      new_state = CONNECTED;
       break;
     case buzz::XmppEngine::STATE_CLOSED:
-      observer_->OnStateChange(StatusObserver::CLOSED);
       // Client is destroyed by the TaskRunner after the client is
       // closed. Reset the pointer so we don't try to use it later.
       xmpp_client_ = NULL;
+      new_state = DISCONNECTED;
       break;
     default:
       NOTREACHED();
-      break;
+      return;
+  }
+
+  if (state_ != new_state) {
+    state_ = new_state;
+    FOR_EACH_OBSERVER(Listener, listeners_,
+                      OnSignalStrategyStateChange(new_state));
   }
 }
 
@@ -145,10 +156,7 @@ buzz::PreXmppAuth* XmppSignalStrategy::CreatePreXmppAuth(
   }
 
   return new notifier::GaiaTokenPreXmppAuth(
-      jid.Str(),
-      settings.auth_cookie(),
-      settings.token_service(),
-      mechanism);
+      jid.Str(), settings.auth_cookie(), settings.token_service(), mechanism);
 }
 
 }  // namespace remoting
diff --git a/remoting/jingle_glue/xmpp_signal_strategy.h b/remoting/jingle_glue/xmpp_signal_strategy.h
index 81426fe..8695c90 100644
--- a/remoting/jingle_glue/xmpp_signal_strategy.h
+++ b/remoting/jingle_glue/xmpp_signal_strategy.h
@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "base/compiler_specific.h"
+#include "base/observer_list.h"
 #include "third_party/libjingle/source/talk/base/sigslot.h"
 #include "third_party/libjingle/source/talk/xmpp/xmppclient.h"
 
@@ -33,8 +34,10 @@ class XmppSignalStrategy : public SignalStrategy,
   virtual ~XmppSignalStrategy();
 
   // SignalStrategy interface.
-  virtual void Init(StatusObserver* observer) OVERRIDE;
-  virtual void Close() OVERRIDE;
+  virtual void Connect() OVERRIDE;
+  virtual void Disconnect() OVERRIDE;
+  virtual State GetState() const OVERRIDE;
+  virtual std::string GetLocalJid() const OVERRIDE;
   virtual void AddListener(Listener* listener) OVERRIDE;
   virtual void RemoveListener(Listener* listener) OVERRIDE;
   virtual bool SendStanza(buzz::XmlElement* stanza) OVERRIDE;
@@ -55,9 +58,9 @@ class XmppSignalStrategy : public SignalStrategy,
   std::string auth_token_service_;
   buzz::XmppClient* xmpp_client_;
 
-  StatusObserver* observer_;
-  std::vector<Listener*> listeners_;
+  State state_;
 
+  ObserverList<Listener> listeners_;
 
   DISALLOW_COPY_AND_ASSIGN(XmppSignalStrategy);
 };