Added HostKeyPair class, signatures for heartbeat messages.

remoting/jingle_glue/jingle_client.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.
 
-// TODO(ajwong): Check the initialization sentinels.  Can we base it off of
-// state_ instead of a member variable?  Also, we assign and read from a few of
-// the member variables on two threads.  We need to audit this for thread
-// safety.
+// TODO(ajwong): We assign and read from a few of the member variables on
+// two threads. We need to audit this for thread safety.
 
 #include "remoting/jingle_glue/jingle_client.h"
 
 #include "base/logging.h"
 #include "base/waitable_event.h"
 #include "base/message_loop.h"
 #include "remoting/jingle_glue/gaia_token_pre_xmpp_auth.h"
+#include "remoting/jingle_glue/iq_request.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/relay_port_allocator.h"
 #include "remoting/jingle_glue/xmpp_socket_adapter.h"
 #include "third_party/libjingle/source/talk/base/asyncsocket.h"
 #include "third_party/libjingle/source/talk/base/ssladapter.h"
 #include "third_party/libjingle/source/talk/p2p/base/sessionmanager.h"
 #include "third_party/libjingle/source/talk/p2p/client/sessionmanagertask.h"
 #ifdef USE_SSL_TUNNEL
 #include "third_party/libjingle/source/talk/session/tunnel/securetunnelsessionclient.h"
 #endif
 #include "third_party/libjingle/source/talk/session/tunnel/tunnelsessionclient.h"
 #include "third_party/libjingle/source/talk/xmpp/prexmppauth.h"
 #include "third_party/libjingle/source/talk/xmpp/saslcookiemechanism.h"
 
 namespace remoting {
 
 JingleClient::JingleClient(JingleThread* thread)
     : client_(NULL),
       thread_(thread),
-      state_(START),
+      state_(CREATED),
       callback_(NULL) {
 }
 
 JingleClient::~JingleClient() {
   // JingleClient can be destroyed only after it's closed.
-  DCHECK(state_ == CLOSED);
+  DCHECK(state_ == CLOSED || state_ == CREATED);
 }
 
 void JingleClient::Init(
     const std::string& username, const std::string& auth_token,
     const std::string& auth_token_service, Callback* callback) {
   DCHECK_NE(username, "");
   DCHECK(callback != NULL);
-  DCHECK(callback_ == NULL);  // Init() can be called only once.
+  DCHECK(state_ == CREATED);
 
   callback_ = callback;
-
   message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &JingleClient::DoInitialize,
                                    username, auth_token, auth_token_service));
+  state_ = INITIALIZED;
 }
 
 JingleChannel* JingleClient::Connect(const std::string& host_jid,
                                      JingleChannel::Callback* callback) {
   // Ownership if channel is given to DoConnect.
   scoped_refptr<JingleChannel> channel = new JingleChannel(callback);
   message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &JingleClient::DoConnect,
                                    channel, host_jid, callback));
   return channel;
@@ skipping 87 matching lines @@
 
   tunnel_session_client_->SignalIncomingTunnel.connect(
       this, &JingleClient::OnIncomingTunnel);
 }
 
 std::string JingleClient::GetFullJid() {
   AutoLock auto_lock(full_jid_lock_);
   return full_jid_;
 }
 
+IqRequest* JingleClient::CreateIqRequest() {
+  return new IqRequest(this);
+}
+
 MessageLoop* JingleClient::message_loop() {
   return thread_->message_loop();
 }
 
 void JingleClient::OnConnectionStateChanged(buzz::XmppEngine::State state) {
   switch (state) {
     case buzz::XmppEngine::STATE_START:
-      UpdateState(START);
+      UpdateState(INITIALIZED);
       break;
     case buzz::XmppEngine::STATE_OPENING:
       UpdateState(CONNECTING);
       break;
     case buzz::XmppEngine::STATE_OPEN:
       {
         AutoLock auto_lock(full_jid_lock_);
         full_jid_ = client_->jid().Str();
       }
       UpdateState(CONNECTED);
@@ skipping 37 matching lines @@
 }
 
 buzz::PreXmppAuth* JingleClient::CreatePreXmppAuth(
     const buzz::XmppClientSettings& settings) {
   buzz::Jid jid(settings.user(), settings.host(), buzz::STR_EMPTY);
   return new GaiaTokenPreXmppAuth(jid.Str(), settings.auth_cookie(),
                                   settings.token_service());
 }
 
 }  // namespace remoting