Use ChannelMojo between the remoting daemon and network processes.

remoting/base/auto_thread_task_runner.h

 // 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.
 
 #ifndef REMOTING_BASE_AUTO_THREAD_TASK_RUNNER_H_
 #define REMOTING_BASE_AUTO_THREAD_TASK_RUNNER_H_
 
 #include <memory>
 
 #include "base/callback.h"
@@ skipping 16 matching lines @@
 
   // SingleThreadTaskRunner implementation
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override;
   bool RunsTasksOnCurrentThread() const override;
 
+  const scoped_refptr<base::SingleThreadTaskRunner>& underlying_task_runner() {

[joedow, 2016/10/20 17:40:03]

What is the problem when passing an instance of this class directly to Mojo
(since it overrides SingleThreadTaskRunner)?  

I'd probably just call this member 'task_runner()'.  It feels odd to indicate in
the property name that encapsulation is being broken by stating 'underlying'.

[Sam McNally, 2016/10/20 22:40:22]

The mojo system holds onto its IO task runner forever so the IO thread never
shuts down and because the IO thread shutdown is set to run on the main thread,
it never stops and so the remoting host never shuts down.

+    return task_runner_;
+  }
+
  private:
   ~AutoThreadTaskRunner() override;
 
   // Task posted to |task_runner_| to notify the caller that it may be stopped.
   base::Closure stop_task_;
 
   // The wrapped task runner.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoThreadTaskRunner);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_BASE_AUTO_THREAD_TASK_RUNNER_H_