Remote assistance on Chrome OS Part IV - It2MeHost

remoting/host/remoting_me2me_host.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 file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "media/base/media.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_server_socket.h"
@@ skipping 108 matching lines @@
 
 namespace remoting {
 
 class HostProcess
     : public ConfigWatcher::Delegate,
       public HeartbeatSender::Listener,
       public HostChangeNotificationListener::Listener,
       public IPC::Listener,
       public base::RefCountedThreadSafe<HostProcess> {
  public:
-  HostProcess(scoped_ptr<ChromotingHostContext> context,
+  HostProcess(scoped_refptr<ChromotingHostContext> context,
               int* exit_code_out);
 
   // ConfigWatcher::Delegate interface.
   virtual void OnConfigUpdated(const std::string& serialized_config) override;
   virtual void OnConfigWatcherError() override;
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) override;
   virtual void OnChannelError() override;
 
@@ skipping 91 matching lines @@
 
   void RestartHost();
 
   // Stops the host and shuts down the process with the specified |exit_code|.
   void ShutdownHost(HostExitCodes exit_code);
 
   void ScheduleHostShutdown();
 
   void ShutdownOnNetworkThread();
 
+  void PostPolicyWatcherShutdown();
+
   // Crashes the process in response to a daemon's request. The daemon passes
   // the location of the code that detected the fatal error resulted in this
   // request.
   void OnCrash(const std::string& function_name,
                const std::string& file_name,
                const int& line_number);
 
-  scoped_ptr<ChromotingHostContext> context_;
+  scoped_refptr<ChromotingHostContext> context_;
 
   // Created on the UI thread but used from the network thread.
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   // Accessed on the UI thread.
   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
 
   // XMPP server/remoting bot configuration (initialized from the command line).
   XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
   std::string directory_bot_jid_;
@@ skipping 57 matching lines @@
 #if defined(REMOTING_MULTI_PROCESS)
   DesktopSessionConnector* desktop_session_connector_;
 #endif  // defined(REMOTING_MULTI_PROCESS)
 
   int* exit_code_out_;
   bool signal_parent_;
 
   scoped_ptr<PairingRegistry::Delegate> pairing_registry_delegate_;
 };
 
-HostProcess::HostProcess(scoped_ptr<ChromotingHostContext> context,
+HostProcess::HostProcess(scoped_refptr<ChromotingHostContext> context,
                          int* exit_code_out)
-    : context_(context.Pass()),
+    : context_(context),
       state_(HOST_INITIALIZING),
       use_service_account_(false),
       enable_vp9_(false),
       frame_recorder_buffer_size_(0),
       host_username_match_required_(false),
       allow_nat_traversal_(true),
       allow_relay_(true),
       min_udp_port_(0),
       max_udp_port_(0),
       allow_pairing_(true),
       curtain_required_(false),
       enable_gnubby_auth_(false),
       enable_window_capture_(false),
       window_id_(0),
 #if defined(REMOTING_MULTI_PROCESS)
       desktop_session_connector_(NULL),
 #endif  // defined(REMOTING_MULTI_PROCESS)
       self_(this),
       exit_code_out_(exit_code_out),
       signal_parent_(false) {
   StartOnUiThread();
 }
 
 HostProcess::~HostProcess() {
   // Verify that UI components have been torn down.
   DCHECK(!config_watcher_);
   DCHECK(!daemon_channel_);
   DCHECK(!desktop_environment_factory_);
-
-  // We might be getting deleted on one of the threads the |host_context| owns,
-  // so we need to post it back to the caller thread to safely join & delete the
-  // threads it contains.  This will go away when we move to AutoThread.
-  // |context_release()| will null |context_| before the method is invoked, so
-  // we need to pull out the task-runner on which to call DeleteSoon first.
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-      context_->ui_task_runner();
-  task_runner->DeleteSoon(FROM_HERE, context_.release());
 }
 
 bool HostProcess::InitWithCommandLine(const base::CommandLine* cmd_line) {
 #if defined(REMOTING_MULTI_PROCESS)
   // Parse the handle value and convert it to a handle/file descriptor.
   std::string channel_name =
       cmd_line->GetSwitchValueASCII(kDaemonPipeSwitchName);
 
   int pipe_handle = 0;
   if (channel_name.empty() ||
@@ skipping 1006 matching lines @@
   oauth_token_getter_.reset();
   signal_strategy_.reset();
   network_change_notifier_.reset();
 
   if (state_ == HOST_STOPPING_TO_RESTART) {
     StartHost();
   } else if (state_ == HOST_STOPPING) {
     state_ = HOST_STOPPED;
 
     if (policy_watcher_.get()) {
-      base::WaitableEvent done_event(true, false);
-      policy_watcher_->StopWatching(&done_event);
-      done_event.Wait();
-      policy_watcher_.reset();
+      policy_watcher_->StopWatching(
+          base::Bind(&HostProcess::PostPolicyWatcherShutdown, this));
+    } else {
+      PostPolicyWatcherShutdown();
     }
-
-    config_watcher_.reset();
-
-    // Complete the rest of shutdown on the main thread.
-    context_->ui_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&HostProcess::ShutdownOnUiThread, this));
   } else {
     // This method is only called in STOPPING_TO_RESTART and STOPPING states.
     NOTREACHED();
   }
 }
 
+void HostProcess::PostPolicyWatcherShutdown() {
+  policy_watcher_.reset();
+
+  // Complete the rest of shutdown on the main thread.
+  context_->ui_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&HostProcess::ShutdownOnUiThread, this));
+}
+
 void HostProcess::OnCrash(const std::string& function_name,
                           const std::string& file_name,
                           const int& line_number) {
   char message[1024];
   base::snprintf(message, sizeof(message),
                  "Requested by %s at %s, line %d.",
                  function_name.c_str(), file_name.c_str(), line_number);
   base::debug::Alias(message);
 
   // The daemon requested us to crash the process.
@@ skipping 13 matching lines @@
 
   // Enable support for SSL server sockets, which must be done while still
   // single-threaded.
   net::EnableSSLServerSockets();
 
   // Ensures runtime specific CPU features are initialized.
   media::InitializeCPUSpecificMediaFeatures();
 
   // Create the main message loop and start helper threads.
   base::MessageLoopForUI message_loop;
-  scoped_ptr<ChromotingHostContext> context =
+  scoped_refptr<ChromotingHostContext> context =
       ChromotingHostContext::Create(new AutoThreadTaskRunner(
           message_loop.message_loop_proxy(), base::MessageLoop::QuitClosure()));
-  if (!context)
+  if (!context.get())
     return kInitializationFailed;
 
   // Create & start the HostProcess using these threads.
   // TODO(wez): The HostProcess holds a reference to itself until Shutdown().
   // Remove this hack as part of the multi-process refactoring.
   int exit_code = kSuccessExitCode;
-  new HostProcess(context.Pass(), &exit_code);
+  new HostProcess(context, &exit_code);
 
   // Run the main (also UI) message loop until the host no longer needs it.
   message_loop.Run();
 
   return exit_code;
 }
 
 }  // namespace remoting