Added HostConfig class. Changed SimpleHost to use it.

remoting/host/chromoting_host.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 "remoting/host/chromoting_host.h"
 
 #include "base/stl_util-inl.h"
 #include "base/waitable_event.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/protocol_decoder.h"
+#include "remoting/host/host_config.h"
 #include "remoting/host/session_manager.h"
 #include "remoting/jingle_glue/jingle_channel.h"
 
 namespace remoting {
 
-ChromotingHost::ChromotingHost(const std::string& username,
-                       const std::string& auth_token,
-                       Capturer* capturer,
-                       Encoder* encoder,
-                       EventExecutor* executor,
-                       base::WaitableEvent* host_done)
+ChromotingHost::ChromotingHost(HostConfig* config,
+                               Capturer* capturer,
+                               Encoder* encoder,
+                               EventExecutor* executor,
+                               base::WaitableEvent* host_done)
       : main_thread_("MainThread"),
         capture_thread_("CaptureThread"),
         encode_thread_("EncodeThread"),
-        username_(username),
-        auth_token_(auth_token),
+        config_(config),
         capturer_(capturer),
         encoder_(encoder),
         executor_(executor),
         host_done_(host_done) {
   // TODO(ajwong): The thread injection and object ownership is odd here.
   // Fix so we do not start this thread in the constructor, so we only
   // take in a session manager, don't let session manager own the
   // capturer/encoder, and then associate the capturer and encoder threads with
   // the capturer and encoder objects directly.  This will require a
   // non-refcounted NewRunnableMethod.
@@ skipping 38 matching lines @@
 }
 
 // This method talks to the cloud to register the host process. If
 // successful we will start listening to network requests.
 void ChromotingHost::RegisterHost() {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK(!jingle_client_);
 
   // Connect to the talk network with a JingleClient.
   jingle_client_ = new JingleClient(&network_thread_);
-  jingle_client_->Init(username_, auth_token_,
+  jingle_client_->Init(config_->xmpp_login(), config_->xmpp_auth_token(),
                        kChromotingTokenServiceName, this);
 }
 
 // This method is called if a client is connected to this object.
 void ChromotingHost::OnClientConnected(ClientConnection* client) {
   DCHECK_EQ(message_loop(), MessageLoop::current());
 
   // Create a new RecordSession if there was none.
   if (!session_.get()) {
     // The first we need to make sure capture and encode thread are
@@ skipping 82 matching lines @@
                                JingleClient::State state) {
   DCHECK_EQ(jingle_client_.get(), jingle_client);
 
   if (state == JingleClient::CONNECTED) {
     LOG(INFO) << "Host connected as "
               << jingle_client->GetFullJid() << "." << std::endl;
 
     // Start heartbeating after we connected
     heartbeat_sender_ = new HeartbeatSender();
     // TODO(sergeyu): where do we get host id?
-    heartbeat_sender_->Start(jingle_client_.get(), "HostID");
+    heartbeat_sender_->Start(config_, jingle_client_.get());
   } else if (state == JingleClient::CLOSED) {
     LOG(INFO) << "Host disconnected from talk network." << std::endl;
     heartbeat_sender_ = NULL;
 
     // Quit the message loop if disconected.
     message_loop()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
     host_done_->Signal();
   }
 }
 
@@ skipping 23 matching lines @@
   // the client directly. Note that we give the ownership of the channel
   // to the client.
   client_->set_jingle_channel(channel);
 }
 
 MessageLoop* ChromotingHost::message_loop() {
   return main_thread_.message_loop();
 }
 
 }  // namespace remoting