Don't crash in ~HostNPScriptObject() when the object wasn't initialized.

remoting/host/plugin/host_script_object.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.
 
 #include "remoting/host/plugin/host_script_object.h"
 #include "remoting/host/plugin/daemon_controller.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 49 matching lines @@
 HostNPScriptObject::HostNPScriptObject(
     NPP plugin,
     NPObject* parent,
     PluginMessageLoopProxy::Delegate* plugin_thread_delegate)
     : plugin_(plugin),
       parent_(parent),
       state_(kDisconnected),
       np_thread_id_(base::PlatformThread::CurrentId()),
       plugin_message_loop_proxy_(
           new PluginMessageLoopProxy(plugin_thread_delegate)),
-      host_context_(plugin_message_loop_proxy_),
       failed_login_attempts_(0),
       daemon_controller_(DaemonController::Create()),
       disconnected_event_(true, false),
       am_currently_logging_(false),
       nat_traversal_enabled_(false),
       policy_received_(false) {
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
 
   // Shutdown It2MeHostUserInterface first so that it doesn't try to post
   // tasks on the UI thread while we are stopping the host.
   if (it2me_host_user_interface_.get()) {
     it2me_host_user_interface_->Shutdown();
   }
 
   HostLogHandler::UnregisterLoggingScriptObject(this);
 
   plugin_message_loop_proxy_->Detach();
 
   // Stop listening for policy updates.
   if (nat_policy_.get()) {
     base::WaitableEvent nat_policy_stopped_(true, false);
     nat_policy_->StopWatching(&nat_policy_stopped_);
     nat_policy_stopped_.Wait();
     nat_policy_.reset();
   }
 
-  // Disconnect synchronously. We cannot disconnect asynchronously
-  // here because |host_context_| needs to be stopped on the plugin
-  // thread, but the plugin thread may not exist after the instance
-  // is destroyed.
-  disconnected_event_.Reset();
-  DisconnectInternal();
-  disconnected_event_.Wait();
+  if (host_context_.get()) {
+    // Disconnect synchronously. We cannot disconnect asynchronously
+    // here because |host_context_| needs to be stopped on the plugin
+    // thread, but the plugin thread may not exist after the instance
+    // is destroyed.
+    disconnected_event_.Reset();
+    DisconnectInternal();
+    disconnected_event_.Wait();
 
-  // Stop all threads.
-  host_context_.Stop();
+    // Stops all threads.
+    host_context_.reset();
+  }
 }
 
 bool HostNPScriptObject::Init() {
   DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
   VLOG(2) << "Init";
-  // TODO(wez): This starts a bunch of threads, which might fail.
-  host_context_.Start();
+
+  host_context_.reset(new ChromotingHostContext(plugin_message_loop_proxy_));
+  if (!host_context_->Start()) {
+    host_context_.reset();
+    return false;
+  }
+
   nat_policy_.reset(
-      policy_hack::NatPolicy::Create(host_context_.network_message_loop()));
+      policy_hack::NatPolicy::Create(host_context_->network_message_loop()));
   nat_policy_->StartWatching(
       base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
                  base::Unretained(this)));
   return true;
 }
 
 bool HostNPScriptObject::HasMethod(const std::string& method_name) {
   VLOG(2) << "HasMethod " << method_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (method_name == kFuncNameConnect ||
@@ skipping 198 matching lines @@
     kFuncNameStartDaemon,
     kFuncNameStopDaemon
   };
   for (size_t i = 0; i < arraysize(entries); ++i) {
     values->push_back(entries[i]);
   }
   return true;
 }
 
 void HostNPScriptObject::OnAccessDenied(const std::string& jid) {
-  DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts) {
     DisconnectInternal();
   }
 }
 
 void HostNPScriptObject::OnClientAuthenticated(const std::string& jid) {
-  DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
 
   if (state_ == kDisconnecting) {
     // Ignore the new connection if we are disconnecting.
     return;
   }
 
   client_username_ = jid;
   size_t pos = client_username_.find('/');
   if (pos != std::string::npos)
     client_username_.replace(pos, std::string::npos, "");
   LOG(INFO) << "Client " << client_username_ << " connected.";
   SetState(kConnected);
 }
 
 void HostNPScriptObject::OnClientDisconnected(const std::string& jid) {
-  DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
   client_username_.clear();
   DisconnectInternal();
 }
 
 void HostNPScriptObject::OnShutdown() {
-  DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
 
   register_request_.reset();
   log_to_server_.reset();
   signal_strategy_.reset();
   host_->RemoveStatusObserver(this);
   host_ = NULL;
 
   if (state_ != kDisconnected) {
     SetState(kDisconnected);
   }
@@ skipping 34 matching lines @@
   }
 
   ReadPolicyAndConnect(uid, auth_token, auth_service);
 
   return true;
 }
 
 void HostNPScriptObject::ReadPolicyAndConnect(const std::string& uid,
                                               const std::string& auth_token,
                                               const std::string& auth_service) {
-  if (!host_context_.network_message_loop()->BelongsToCurrentThread()) {
-    host_context_.network_message_loop()->PostTask(
+  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
+    host_context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::ReadPolicyAndConnect, base::Unretained(this),
             uid, auth_token, auth_service));
     return;
   }
 
   SetState(kStarting);
 
   // Only proceed to FinishConnect() if at least one policy update has been
   // received.
   if (policy_received_) {
     FinishConnectMainThread(uid, auth_token, auth_service);
   } else {
     // Otherwise, create the policy watcher, and thunk the connect.
     pending_connect_ =
         base::Bind(&HostNPScriptObject::FinishConnectMainThread,
                    base::Unretained(this), uid, auth_token, auth_service);
   }
 }
 
 void HostNPScriptObject::FinishConnectMainThread(
     const std::string& uid,
     const std::string& auth_token,
     const std::string& auth_service) {
-  if (host_context_.main_message_loop() != MessageLoop::current()) {
-    host_context_.main_message_loop()->PostTask(FROM_HERE, base::Bind(
+  if (host_context_->main_message_loop() != MessageLoop::current()) {
+    host_context_->main_message_loop()->PostTask(FROM_HERE, base::Bind(
         &HostNPScriptObject::FinishConnectMainThread, base::Unretained(this),
         uid, auth_token, auth_service));
     return;
   }
 
   // DesktopEnvironment must be initialized on the main thread.
   //
   // TODO(sergeyu): Fix DesktopEnvironment so that it can be created
   // on either the UI or the network thread so that we can avoid
   // jumping to the main thread here.
-  desktop_environment_.reset(DesktopEnvironment::Create(&host_context_));
+  desktop_environment_.reset(DesktopEnvironment::Create(host_context_.get()));
 
   FinishConnectNetworkThread(uid, auth_token, auth_service);
 }
 
 void HostNPScriptObject::FinishConnectNetworkThread(
     const std::string& uid,
     const std::string& auth_token,
     const std::string& auth_service) {
-  if (!host_context_.network_message_loop()->BelongsToCurrentThread()) {
-    host_context_.network_message_loop()->PostTask(FROM_HERE, base::Bind(
+  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
+    host_context_->network_message_loop()->PostTask(FROM_HERE, base::Bind(
         &HostNPScriptObject::FinishConnectNetworkThread, base::Unretained(this),
         uid, auth_token, auth_service));
     return;
   }
 
   if (state_ != kStarting) {
     // Host has been stopped while we were fetching policy.
     return;
   }
 
   // Verify that DesktopEnvironment has been created.
   if (desktop_environment_.get() == NULL) {
     SetState(kError);
     return;
   }
 
   // Generate a key pair for the Host to use.
   // TODO(wez): Move this to the worker thread.
   host_key_pair_.Generate();
 
   // Create XMPP connection.
   scoped_ptr<SignalStrategy> signal_strategy(
-      new XmppSignalStrategy(host_context_.jingle_thread(), uid,
+      new XmppSignalStrategy(host_context_->jingle_thread(), uid,
                              auth_token, auth_service));
 
   // Request registration of the host for support.
   scoped_ptr<RegisterSupportHostRequest> register_request(
       new RegisterSupportHostRequest(
           signal_strategy.get(), &host_key_pair_,
           base::Bind(&HostNPScriptObject::OnReceivedSupportID,
                      base::Unretained(this))));
 
   // Beyond this point nothing can fail, so save the config and request.
   signal_strategy_.reset(signal_strategy.release());
   register_request_.reset(register_request.release());
 
   // Create the Host.
   LOG(INFO) << "NAT state: " << nat_traversal_enabled_;
   host_ = new ChromotingHost(
-      &host_context_, signal_strategy_.get(), desktop_environment_.get(),
+      host_context_.get(), signal_strategy_.get(), desktop_environment_.get(),
       protocol::NetworkSettings(nat_traversal_enabled_));
   host_->AddStatusObserver(this);
   log_to_server_.reset(
       new LogToServer(host_, ServerLogEntry::IT2ME, signal_strategy_.get()));
   it2me_host_user_interface_.reset(
-      new It2MeHostUserInterface(host_.get(), &host_context_));
+      new It2MeHostUserInterface(host_.get(), host_context_.get()));
   it2me_host_user_interface_->Init();
 
   {
     base::AutoLock auto_lock(ui_strings_lock_);
     host_->SetUiStrings(ui_strings_);
   }
 
   signal_strategy_->Connect();
   host_->Start();
 
@@ skipping 70 matching lines @@
   if (arg_count != 0) {
     SetException("startDaemon: bad number of arguments");
     return false;
   }
   bool stop_result = daemon_controller_->Stop();
   BOOLEAN_TO_NPVARIANT(stop_result, *result);
   return true;
 }
 
 void HostNPScriptObject::DisconnectInternal() {
-  if (!host_context_.network_message_loop()->BelongsToCurrentThread()) {
-    host_context_.network_message_loop()->PostTask(
+  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
+    host_context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&HostNPScriptObject::DisconnectInternal,
                               base::Unretained(this)));
     return;
   }
 
   switch (state_) {
     case kDisconnected:
       disconnected_event_.Signal();
       return;
 
     case kStarting:
       SetState(kDisconnecting);
       SetState(kDisconnected);
       disconnected_event_.Signal();
       return;
 
     case kDisconnecting:
       return;
 
     default:
       DCHECK(host_);
       SetState(kDisconnecting);
 
       // ChromotingHost::Shutdown() may destroy SignalStrategy
       // synchronously, bug SignalStrategy::Listener handlers are not
       // allowed to destroy SignalStrategy, so post task to call
       // Shutdown() later.
-      host_context_.network_message_loop()->PostTask(
+      host_context_->network_message_loop()->PostTask(
           FROM_HERE, base::Bind(
               &ChromotingHost::Shutdown, host_,
               base::Bind(&HostNPScriptObject::OnShutdownFinished,
                          base::Unretained(this))));
   }
 }
 
 void HostNPScriptObject::OnShutdownFinished() {
-  DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
 
   disconnected_event_.Signal();
 }
 
 void HostNPScriptObject::OnNatPolicyUpdate(bool nat_traversal_enabled) {
-  if (!host_context_.network_message_loop()->BelongsToCurrentThread()) {
-    host_context_.network_message_loop()->PostTask(
+  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
+    host_context_->network_message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
                    base::Unretained(this), nat_traversal_enabled));
     return;
   }
 
   VLOG(2) << "OnNatPolicyUpdate: " << nat_traversal_enabled;
 
   // When transitioning from enabled to disabled, force disconnect any
   // existing session.
@@ skipping 12 matching lines @@
   if (!pending_connect_.is_null()) {
     pending_connect_.Run();
     pending_connect_.Reset();
   }
 }
 
 void HostNPScriptObject::OnReceivedSupportID(
     bool success,
     const std::string& support_id,
     const base::TimeDelta& lifetime) {
-  DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
 
   if (!success) {
     SetState(kError);
     DisconnectInternal();
     return;
   }
 
   std::string host_secret = GenerateSupportHostSecret();
   std::string access_code = support_id + host_secret;
   scoped_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
           host_key_pair_.GenerateCertificate(), *host_key_pair_.private_key(),
           access_code));
   host_->SetAuthenticatorFactory(factory.Pass());
 
   {
     base::AutoLock lock(access_code_lock_);
     access_code_ = access_code;
     access_code_lifetime_ = lifetime;
   }
 
   SetState(kReceivedAccessCode);
 }
 
 void HostNPScriptObject::SetState(State state) {
-  DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
   switch (state_) {
     case kDisconnected:
       DCHECK(state == kStarting ||
              state == kError) << state;
       break;
     case kStarting:
       DCHECK(state == kRequestedAccessCode ||
              state == kDisconnecting ||
              state == kError) << state;
       break;
@@ skipping 151 matching lines @@
                                                uint32_t argCount) {
   NPVariant np_result;
   bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
                                                    argCount, &np_result);
   if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
   return is_good;
 }
 
 }  // namespace remoting