Set empty shared secret for Me2Me hosts.

remoting/host/chromoting_host.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 "remoting/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
@@ skipping 30 matching lines @@
 }
 
 ChromotingHost::ChromotingHost(ChromotingHostContext* context,
                                MutableHostConfig* config,
                                DesktopEnvironment* environment,
                                bool allow_nat_traversal)
     : context_(context),
       desktop_environment_(environment),
       config_(config),
       allow_nat_traversal_(allow_nat_traversal),
+      have_shared_secret_(false),
       stopping_recorders_(0),
       state_(kInitial),
       protocol_config_(protocol::CandidateSessionConfig::CreateDefault()),
       is_it2me_(false) {
   DCHECK(desktop_environment_);
   desktop_environment_->set_host(this);
 }
 
 ChromotingHost::~ChromotingHost() {
   DCHECK(clients_.empty());
@@ skipping 66 matching lines @@
 
   // Stop session manager.
   if (session_manager_.get()) {
     session_manager_->Close();
     // It may not be safe to delete |session_manager_| here becase
     // this method may be invoked in response to a libjingle event and
     // libjingle's sigslot doesn't handle it properly, so postpone the
     // deletion.
     context_->network_message_loop()->DeleteSoon(
         FROM_HERE, session_manager_.release());
+    have_shared_secret_ = false;
   }
 
   // Stop XMPP connection synchronously.
   if (signal_strategy_.get()) {
     signal_strategy_->Close();
     signal_strategy_.reset();
 
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnSignallingDisconnected();
     }
   }
 
   if (recorder_.get()) {
     StopScreenRecorder();
   } else {
     ShutdownFinish();
   }
 }
 
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK_EQ(state_, kInitial);
   status_observers_.push_back(observer);
 }
 
 void ChromotingHost::SetSharedSecret(const std::string& shared_secret) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
-  session_manager_->set_authenticator_factory(
-      new protocol::V1HostAuthenticatorFactory(
-          key_pair_.GenerateCertificate(), key_pair_.private_key(),
-          shared_secret));
+  shared_secret_ = shared_secret;
+  have_shared_secret_ = true;
+  if (session_manager_.get()) {
+    session_manager_->set_authenticator_factory(
+        new protocol::V1HostAuthenticatorFactory(
+            key_pair_.GenerateCertificate(), key_pair_.private_key(),
+            shared_secret_));
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ClientSession::EventHandler implementation.
 void ChromotingHost::OnSessionAuthenticated(ClientSession* client) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   // Disconnect all other clients.
   // Iterate over a copy of the list of clients, to avoid mutating the list
   // while iterating over it.
@@ skipping 81 matching lines @@
     LOG(INFO) << "Host connected as " << local_jid_;
 
     // Create and start session manager.
     protocol::JingleSessionManager* server =
         new protocol::JingleSessionManager(context_->network_message_loop());
 
     server->Init(local_jid_, signal_strategy_.get(),
                  this, allow_nat_traversal_);
 
     session_manager_.reset(server);
+    if (have_shared_secret_) {
+      session_manager_->set_authenticator_factory(
+          new protocol::V1HostAuthenticatorFactory(
+              key_pair_.GenerateCertificate(), key_pair_.private_key(),
+              shared_secret_));
+    }
 
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnSignallingConnected(signal_strategy_.get(), local_jid_);
     }
   } else if (state == SignalStrategy::StatusObserver::CLOSED) {
     LOG(INFO) << "Host disconnected from talk network.";
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnSignallingDisconnected();
@@ skipping 168 matching lines @@
   }
 
   for (std::vector<base::Closure>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     it->Run();
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting