Add HostObserverInterface and decouple HeartbeatSender and ChromotingHost.

remoting/host/heartbeat_sender_unittest.cc

 // Copyright (c) 2011 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 "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/heartbeat_sender.h"
@@ skipping 57 matching lines @@
  private:
   scoped_ptr<IqRequest::ReplyCallback> callback_;
 };
 
 class HeartbeatSenderTest : public testing::Test {
  protected:
   virtual void SetUp() {
     config_ = new InMemoryHostConfig();
     config_->SetString(kHostIdConfigPath, kHostId);
     config_->SetString(kPrivateKeyConfigPath, kTestHostKeyPair);
-
-    jingle_thread_.message_loop_ = &message_loop_;
-
-    signal_strategy_.reset(new MockSignalStrategy());
-    jingle_client_ =
-        new JingleClient(&jingle_thread_, signal_strategy_.get(), NULL, NULL);
-    jingle_client_->full_jid_ = kTestJid;
   }
 
-  JingleThread jingle_thread_;
-  scoped_ptr<MockSignalStrategy> signal_strategy_;
-  scoped_refptr<JingleClient> jingle_client_;
+  MockSignalStrategy signal_strategy_;
   MessageLoop message_loop_;
   scoped_refptr<InMemoryHostConfig> config_;
 };
 
 // Call Start() followed by Stop(), and makes sure an Iq stanza is
 // being send.
 TEST_F(HeartbeatSenderTest, DoSendStanza) {
   // |iq_request| is freed by HeartbeatSender.
   MockIqRequest* iq_request = new MockIqRequest();
   iq_request->Init();
 
   EXPECT_CALL(*iq_request, set_callback(_)).Times(1);
 
   scoped_refptr<HeartbeatSender> heartbeat_sender(
-      new HeartbeatSender(&message_loop_, jingle_client_.get(), config_));
+      new HeartbeatSender(&message_loop_, config_));
   ASSERT_TRUE(heartbeat_sender->Init());
 
-  EXPECT_CALL(*signal_strategy_, CreateIqRequest())
+  EXPECT_CALL(signal_strategy_, CreateIqRequest())
       .WillOnce(Return(iq_request));
 
   EXPECT_CALL(*iq_request, SendIq(buzz::STR_SET, kChromotingBotJid, NotNull()))
       .WillOnce(DoAll(DeleteArg<2>(), Return()));
 
-  heartbeat_sender->Start();
+  heartbeat_sender->OnSignallingConnected(&signal_strategy_, kTestJid);
   message_loop_.RunAllPending();
 
-  heartbeat_sender->Stop();
+  heartbeat_sender->OnSignallingDisconnected();
   message_loop_.RunAllPending();
 }
 
 // Validate format of the heartbeat stanza.
 TEST_F(HeartbeatSenderTest, CreateHeartbeatMessage) {
   scoped_refptr<HeartbeatSender> heartbeat_sender(
-      new HeartbeatSender(&message_loop_, jingle_client_.get(), config_));
+      new HeartbeatSender(&message_loop_, config_));
   ASSERT_TRUE(heartbeat_sender->Init());
 
   int64 start_time = static_cast<int64>(base::Time::Now().ToDoubleT());
 
-  scoped_ptr<XmlElement> stanza(
-      heartbeat_sender->CreateHeartbeatMessage());
+  heartbeat_sender->full_jid_ = kTestJid;
+  scoped_ptr<XmlElement> stanza(heartbeat_sender->CreateHeartbeatMessage());
   ASSERT_TRUE(stanza.get() != NULL);
 
   EXPECT_TRUE(QName(kChromotingXmlNamespace, "heartbeat") ==
               stanza->Name());
   EXPECT_EQ(std::string(kHostId),
             stanza->Attr(QName(kChromotingXmlNamespace, "hostid")));
 
   QName signature_tag(kChromotingXmlNamespace, "signature");
   XmlElement* signature = stanza->FirstNamed(signature_tag);
   ASSERT_TRUE(signature != NULL);
@@ skipping 24 matching lines @@
   response->AddElement(result);
 
   XmlElement* set_interval = new XmlElement(
       QName(kChromotingXmlNamespace, "set-interval"));
   result->AddElement(set_interval);
 
   const int kTestInterval = 123;
   set_interval->AddText(base::IntToString(kTestInterval));
 
   scoped_refptr<HeartbeatSender> heartbeat_sender(
-      new HeartbeatSender(&message_loop_, jingle_client_.get(), config_));
+      new HeartbeatSender(&message_loop_, config_));
   heartbeat_sender->ProcessResponse(response.get());
 
   EXPECT_EQ(kTestInterval * 1000, heartbeat_sender->interval_ms_);
 }
 
 }  // namespace remoting