Refactoring Elevated Host Communication Channel into its own class.

remoting/host/win/elevated_native_messaging_host.cc

Index: remoting/host/win/elevated_native_messaging_host.cc
diff --git a/remoting/host/win/elevated_native_messaging_host.cc b/remoting/host/win/elevated_native_messaging_host.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6981284fee2490fee392c82b7b2643093e8de681
--- /dev/null
+++ b/remoting/host/win/elevated_native_messaging_host.cc
@@ -0,0 +1,99 @@
+// Copyright 2016 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/win/elevated_native_messaging_host.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/json/json_writer.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/values.h"
+#include "base/win/scoped_handle.h"
+#include "remoting/host/native_messaging/pipe_messaging_channel.h"
+#include "remoting/host/win/launch_native_messaging_host_process.h"
+
+namespace remoting {
+
+ElevatedNativeMessagingHost::ElevatedNativeMessagingHost(
+    const base::FilePath& binary_path,
+    intptr_t parent_window_handle,
+    bool elevate_process,
+    base::TimeDelta host_timeout,
+    extensions::NativeMessageHost::Client* client)
+    : host_binary_path_(binary_path),
+      parent_window_handle_(parent_window_handle),
+      elevate_host_process_(elevate_process),
+      host_process_timeout_(host_timeout),
+      client_(client) {}
+
+ElevatedNativeMessagingHost::~ElevatedNativeMessagingHost() {}
+
+void ElevatedNativeMessagingHost::OnMessage(
+    std::unique_ptr<base::Value> message) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Simply pass along the response from the elevated host to the client.
+  std::string message_json;
+  base::JSONWriter::Write(*message, &message_json);
+  client_->PostMessageFromNativeHost(message_json);
+}
+
+void ElevatedNativeMessagingHost::OnDisconnect() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  client_->CloseChannel(std::string());
+}
+
+bool ElevatedNativeMessagingHost::EnsureElevatedHostCreated() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (elevated_channel_) {

[Sergey Ulanov, 2016/08/02 21:18:27]

Do we need to support the case when  EnsureElevatedHostCreated() is called
multiple times? Maybe rename it to Initialize() or Start() and allow it to be
called only once?

[joedow, 2016/08/08 23:45:16]

We need to support the elevated host being created multiple times during the
instances lifetime.  Whether that is in this method or a different one is the
question.

For example, the Me2Me NMH launches the elevated process to start/stop the host
service, but the elevated process is torn down after 5 minutes.  If the user
enables the host (for example) which requires elevation, then leaves the webapp
open for 6 minutes, then decides to disable the host, then a new elevated
process will be created to handle that task.

I think it is cleaner to wrap that logic in this method so the consumer of this
class does not know if an elevated process exists or not.

+    return true;
+  }
+
+  base::win::ScopedHandle read_handle;
+  base::win::ScopedHandle write_handle;
+  ProcessLaunchResult result = LaunchNativeMessagingHostProcess(
+      host_binary_path_, parent_window_handle_, elevate_host_process_,
+      &read_handle, &write_handle);
+  if (result != PROCESS_LAUNCH_RESULT_SUCCESS) {
+    if (result != PROCESS_LAUNCH_RESULT_CANCELLED) {
+      client_->CloseChannel(std::string());

[Sergey Ulanov, 2016/08/02 21:18:27]

I'm not sure it's safe to call CloseChannel() here - see my comment in
me2me_native_messaging_host.cc

[joedow, 2016/08/08 23:45:16]

Done.  Removed in an upstream change actually.

+    }
+    return false;
+  }
+
+  // Set up the native messaging channel to talk to the elevated host.
+  // Note that input for the elevated channel is output for the elevated host.
+  elevated_channel_.reset(new PipeMessagingChannel(
+      base::File(read_handle.Take()), base::File(write_handle.Take())));
+  elevated_channel_->Start(this);
+
+  if (!host_process_timeout_.is_zero()) {
+    elevated_host_timer_.Start(
+        FROM_HERE, host_process_timeout_,
+        this, &ElevatedNativeMessagingHost::DisconnectHost);
+  }
+
+  return true;
+}
+
+void ElevatedNativeMessagingHost::SendMessage(
+    std::unique_ptr<base::Value> message) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  elevated_channel_->SendMessage(std::move(message));
+}
+
+void ElevatedNativeMessagingHost::DisconnectHost() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // This will send an EOF to the elevated host, triggering its shutdown.
+  elevated_channel_.reset();
+}
+
+}  // namespace remoting