Verify that xmpp_login specified in the config matches auth token.

remoting/host/simple_host_process.cc

 // Copyright (c) 2012 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.
 //
 // This is an application of a minimal host process in a Chromoting
 // system. It serves the purpose of gluing different pieces together
 // to make a functional host process for testing.
 //
 // It peforms the following functionality:
 // 1. Connect to the GTalk network and register the machine as a host.
@@ skipping 17 matching lines @@
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "crypto/nss_util.h"
 #include "net/base/network_change_notifier.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
+#include "remoting/host/constants.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/host_key_pair.h"
 #include "remoting/host/host_secret.h"
 #include "remoting/host/it2me_host_user_interface.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/host/signaling_connector.h"
@@ skipping 39 matching lines @@
 }  // namespace
 
 namespace remoting {
 
 class SimpleHost : public HeartbeatSender::Listener {
  public:
   SimpleHost()
       : message_loop_(MessageLoop::TYPE_UI),
         context_(message_loop_.message_loop_proxy()),
         fake_(false),
-        is_it2me_(false) {
+        is_it2me_(false),
+        shutting_down_(false),
+        exit_code_(kSuccessExitCode) {
     context_.Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
   }
 
   // Overridden from HeartbeatSender::Listener
   virtual void OnUnknownHostIdError() OVERRIDE {
     LOG(ERROR) << "Host ID not found.";
-    Shutdown();
+    Shutdown(kInvalidHostIdExitCode);
   }
 
   int Run() {
     FilePath config_path = GetConfigPath();
     JsonHostConfig config(config_path);
     if (!config.Read()) {
       LOG(ERROR) << "Failed to read configuration file "
                  << config_path.value();
       return 1;
     }
@@ skipping 30 matching lines @@
       // easily request an OAuth2 access token even if we had a RefreshToken for
       // the account.
       xmpp_auth_service_ = kChromotingTokenDefaultServiceName;
     }
 
     context_.network_message_loop()->PostTask(FROM_HERE, base::Bind(
         &SimpleHost::StartHost, base::Unretained(this)));
 
     message_loop_.MessageLoop::Run();
 
-    return 0;
+    return exit_code_;
   }
 
   void set_config_path(const FilePath& config_path) {
     config_path_ = config_path;
   }
   void set_fake(bool fake) { fake_ = fake; }
   void set_is_it2me(bool is_it2me) { is_it2me_ = is_it2me; }
   void set_protocol_config(CandidateSessionConfig* protocol_config) {
     protocol_config_.reset(protocol_config);
   }
@@ skipping 40 matching lines @@
     std::string home_path;
     env->GetVar(base::env_vars::kHome, &home_path);
     return FilePath(home_path).Append(kDefaultConfigPath);
 #endif
   }
 
   void StartHost() {
     signal_strategy_.reset(
         new XmppSignalStrategy(context_.jingle_thread(), xmpp_login_,
                                xmpp_auth_token_, xmpp_auth_service_));
-    signaling_connector_.reset(new SignalingConnector(signal_strategy_.get()));
+    signaling_connector_.reset(new SignalingConnector(
+        signal_strategy_.get(),
+        base::Bind(&SimpleHost::OnAuthFailed, base::Unretained(this))));
 
     if (fake_) {
       scoped_ptr<Capturer> capturer(new CapturerFake());
       scoped_ptr<protocol::HostEventStub> event_executor =
           EventExecutor::Create(
               context_.desktop_message_loop(), capturer.get());
       desktop_environment_ = DesktopEnvironment::CreateFake(
           &context_, capturer.Pass(), event_executor.Pass());
     } else {
       desktop_environment_ = DesktopEnvironment::Create(&context_);
@@ skipping 30 matching lines @@
     // Create a Me2Me authenticator factory.
     if (!is_it2me_) {
       scoped_ptr<protocol::AuthenticatorFactory> factory(
           new protocol::Me2MeHostAuthenticatorFactory(
               xmpp_login_, key_pair_.GenerateCertificate(),
               *key_pair_.private_key(), host_secret_hash_));
       host_->SetAuthenticatorFactory(factory.Pass());
     }
   }
 
-  void Shutdown() {
+  void OnAuthFailed() {
+    Shutdown(kInvalidOauthCredentialsExitCode);
+  }
+
+  void Shutdown(int exit_code) {
+    DCHECK(context_.network_message_loop()->BelongsToCurrentThread());
+
+    if (shutting_down_)
+      return;
+
+    shutting_down_ = true;
+    exit_code_ = exit_code;
+    host_->Shutdown(base::Bind(
+        &SimpleHost::OnShutdownFinished, base::Unretained(this)));
+  }
+
+  void OnShutdownFinished() {
+    DCHECK(context_.network_message_loop()->BelongsToCurrentThread());
+
+    // Destroy networking objects while we are on the network thread.
+    host_ = NULL;
+    log_to_server_.reset();
+    heartbeat_sender_.reset();
+    signaling_connector_.reset();
+    signal_strategy_.reset();
+
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   MessageLoop message_loop_;
   ChromotingHostContext context_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath config_path_;
   bool fake_;
   bool is_it2me_;
   NetworkSettings network_settings_;
   scoped_ptr<CandidateSessionConfig> protocol_config_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface_;
   scoped_ptr<RegisterSupportHostRequest> register_request_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
 
   scoped_refptr<ChromotingHost> host_;
+
+  bool shutting_down_;
+  int exit_code_;
 };
 
 } // namespace remoting
 
 int main(int argc, char** argv) {
 #if defined(OS_MACOSX)
   // Needed so we don't leak objects when threads are created.
   base::mac::ScopedNSAutoreleasePool pool;
 #endif
 
@@ skipping 68 matching lines @@
         max_port < 0 || max_port > 65535) {
       LOG(ERROR) << "Invalid max-port value: " << max_port
                  << ". Expected integer in range [0, 65535].";
       return 1;
     }
     simple_host.network_settings()->max_port = max_port;
   }
 
   return simple_host.Run();
 }