[mojo] Use a pipe path to initialise Mojo in elevated utility processes.

mojo/edk/system/channel_win.cc

 // 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 "mojo/edk/system/channel.h"
 
 #include <stdint.h>
 #include <windows.h>
 
 #include <algorithm>
@@ skipping 67 matching lines @@
         self_(this),
         handle_(std::move(handle)),
         io_task_runner_(io_task_runner) {
     sentinel_ = ~reinterpret_cast<uintptr_t>(this);
     CHECK(handle_.is_valid());
     memset(&read_context_, 0, sizeof(read_context_));
     read_context_.handler = this;
 
     memset(&write_context_, 0, sizeof(write_context_));
     write_context_.handler = this;
+
+    wait_for_connect_ = handle_.get().needs_connection;
   }
 
   void Start() override {
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ChannelWin::StartOnIOThread, this));
   }
 
   void ShutDownImpl() override {
     // Always shut down asynchronously when called through the public interface.
     io_task_runner_->PostTask(
@@ skipping 43 matching lines @@
     // value lets us detect the difference between just destroying, and
     // re-allocating the memory.
     sentinel_ = UINTPTR_MAX;
   }
 
   void StartOnIOThread() {
     base::MessageLoop::current()->AddDestructionObserver(this);
     base::MessageLoopForIO::current()->RegisterIOHandler(
         handle_.get().handle, this);
 
+    if (wait_for_connect_) {
+      BOOL ok = ConnectNamedPipe(handle_.get().handle,
+                                 &read_context_.overlapped);

[Ken Rockot(use gerrit already), 2016/05/10 22:41:28]

I'd rather we use a separate IO context for connection events. That makes
OnIOCompleted easier to understand

[Anand Mistry (off Chromium), 2016/05/11 04:15:20]

Done.

+      if (ok) {
+        PLOG(ERROR) << "Unexpected success while waiting for pipe connection";
+        OnError();
+        return;
+      }
+
+      const DWORD err = GetLastError();
+      switch (err) {
+        case ERROR_PIPE_CONNECTED:
+          wait_for_connect_ = false;
+          break;
+        case ERROR_IO_PENDING:
+          AddRef();
+          return;
+        case ERROR_NO_DATA:
+          OnError();
+          return;
+      }
+    }
+
     // Now that we have registered our IOHandler, we can start writing.
     {
       base::AutoLock lock(write_lock_);
       if (delay_writes_) {
         delay_writes_ = false;
         WriteNextNoLock();
       }
     }
 
     // Keep this alive in case we synchronously run shutdown.
@@ skipping 23 matching lines @@
   }
 
   // base::MessageLoop::IOHandler:
   void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                      DWORD bytes_transfered,
                      DWORD error) override {
     CheckValid();
     if (error != ERROR_SUCCESS) {
       OnError();
     } else if (context == &read_context_) {
-      OnReadDone(static_cast<size_t>(bytes_transfered));
+      if (wait_for_connect_) {
+        wait_for_connect_ = false;
+        ReadMore(0);
+
+        base::AutoLock lock(write_lock_);
+        if (delay_writes_) {
+          delay_writes_ = false;
+          WriteNextNoLock();
+        }
+      } else {
+        OnReadDone(static_cast<size_t>(bytes_transfered));
+      }
     } else {
       CHECK(context == &write_context_);
       OnWriteDone(static_cast<size_t>(bytes_transfered));
     }
     Release();  // Balancing reference taken after ReadFile / WriteFile.
   }
 
   void OnReadDone(size_t bytes_read) {
     if (bytes_read > 0) {
       size_t next_read_size = 0;
@@ skipping 97 matching lines @@
 
   bool reject_writes_ = false;
   std::deque<MessageView> outgoing_messages_;
 
   // A value that is unlikely to be valid if this object is destroyed and the
   // memory overwritten by something else. When this is valid, its value will be
   // ~|this|.
   // TODO(amistry): Remove before M50 branch point.
   uintptr_t sentinel_;
 
+  bool wait_for_connect_;
+
   DISALLOW_COPY_AND_ASSIGN(ChannelWin);
 };
 
 }  // namespace
 
 // static
 scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ScopedPlatformHandle platform_handle,
     scoped_refptr<base::TaskRunner> io_task_runner) {
   return new ChannelWin(delegate, std::move(platform_handle), io_task_runner);
 }
 
 }  // namespace edk
 }  // namespace mojo