Use ChannelMojo for NaCl PPAPI channels.

components/nacl/browser/nacl_process_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.
 
 #include "components/nacl/browser/nacl_process_host.h"
 
 #include <string.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 198 matching lines @@
 }  // namespace
 
 unsigned NaClProcessHost::keepalive_throttle_interval_milliseconds_ =
     ppapi::kKeepaliveThrottleIntervalDefaultMilliseconds;
 
 // Unfortunately, we cannot use ScopedGeneric directly for IPC::ChannelHandle,
 // because there is neither operator== nor operator != definition for it.
 // Instead, define a simple wrapper for IPC::ChannelHandle with an assumption
 // that this only takes a transferred IPC::ChannelHandle or one to be
 // transferred via IPC.
 class NaClProcessHost::ScopedChannelHandle {

[Mark Seaborn, 2016/10/13 21:27:51]

Presumably at some point this could be removed and we could just use a
ScopedMessagePipeHandle?  Not sure if that's worth a TODO to point that out.

[Sam McNally, 2016/10/14 02:35:02]

How about now? :)

  public:
   ScopedChannelHandle() {
   }
   explicit ScopedChannelHandle(const IPC::ChannelHandle& handle)
       : handle_(handle) {
     DCHECK(IsSupportedHandle(handle_));
   }
   ScopedChannelHandle(ScopedChannelHandle&& other) : handle_(other.handle_) {
     other.handle_ = IPC::ChannelHandle();
     DCHECK(IsSupportedHandle(handle_));
   }
   ~ScopedChannelHandle() {
     CloseIfNecessary();
   }
 
   const IPC::ChannelHandle& get() const { return handle_; }
   IPC::ChannelHandle release() WARN_UNUSED_RESULT {
     IPC::ChannelHandle result = handle_;
     handle_ = IPC::ChannelHandle();
     return result;
   }
 
-  void reset(const IPC::ChannelHandle& handle = IPC::ChannelHandle()) {
+  void reset() {
+    CloseIfNecessary();
+    handle_ = IPC::ChannelHandle();
+  }
+
+  void reset(const IPC::ChannelHandle& handle) {
     DCHECK(IsSupportedHandle(handle));
-#if defined(OS_POSIX)
     // Following the manner of base::ScopedGeneric, we do not support
     // reset() with same handle for simplicity of the implementation.
-    CHECK(handle.socket.fd == -1 || handle.socket.fd != handle_.socket.fd);
-#endif
+    CHECK(handle.mojo_handle.value() != handle_.mojo_handle.value());
     CloseIfNecessary();
     handle_ = handle;
   }
 
  private:
   // Returns true if the given handle is closable automatically by this
   // class. This function is just a helper for validation.
   static bool IsSupportedHandle(const IPC::ChannelHandle& handle) {
-#if defined(OS_WIN)
-    // On Windows, it is not supported to marshal the |pipe.handle|.
-    // In our case, we wrap a transferred ChannelHandle (or one to be
-    // transferred) via IPC, so we can assume |handle.pipe.handle| is NULL.
-    return handle.pipe.handle == NULL;
-#else
-    return true;
-#endif
+    // Only ChannelMojo is supported.
+    return handle.mojo_handle.is_valid();
   }
 
   void CloseIfNecessary() {
-#if defined(OS_POSIX)
-    if (handle_.socket.auto_close) {
-      // Defer closing task to the ScopedFD.
-      base::ScopedFD(handle_.socket.fd);
-    }
-#endif
+    if (handle_.mojo_handle.is_valid())
+      handle_.mojo_handle.Close();
   }
 
   IPC::ChannelHandle handle_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedChannelHandle);
 };
 
 NaClProcessHost::NaClProcessHost(
     const GURL& manifest_url,
     base::File nexe_file,
@@ skipping 742 matching lines @@
 }
 
 #if defined(OS_LINUX)
 // static
 bool NaClProcessHost::CreateChannelHandlePair(
     ScopedChannelHandle* channel_handle1,
     ScopedChannelHandle* channel_handle2) {
   DCHECK(channel_handle1);
   DCHECK(channel_handle2);
 
-  int fd1 = -1;
-  int fd2 = -1;
-  if (!IPC::SocketPair(&fd1, &fd2)) {
-    return false;
-  }
+  IPC::ChannelHandle handle1;
+  IPC::ChannelHandle handle2;
+  IPC::Channel::GenerateMojoChannelHandlePair("NaCl", &handle1, &handle2);
+  channel_handle1->reset(handle1);
+  channel_handle2->reset(handle2);
 
-  IPC::ChannelHandle handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
-  handle.socket = base::FileDescriptor(fd1, true);
-  channel_handle1->reset(handle);
-  handle.socket = base::FileDescriptor(fd2, true);
-  channel_handle2->reset(handle);
   return true;
 }
 #endif
 
 bool NaClProcessHost::StartPPAPIProxy(ScopedChannelHandle channel_handle) {
   if (ipc_proxy_channel_.get()) {
     // Attempt to open more than 1 browser channel is not supported.
     // Shut down the NaCl process.
     process_->GetHost()->ForceShutdown();
     return false;
@@ skipping 241 matching lines @@
     NaClStartDebugExceptionHandlerThread(
         std::move(process), info, base::ThreadTaskRunnerHandle::Get(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl