Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

ipc/mojo/async_handle_waiter.cc

 // Copyright 2015 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 "ipc/mojo/async_handle_waiter.h"
 
 #include "base/atomic_ref_count.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
+
+#if defined(USE_CHROME_EDK)
+#include "mojo/edk/embedder/embedder.h"
+#else
 #include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
+#endif
 
 namespace IPC {
 namespace internal {
 
 class AsyncHandleWaiterContextTraits {
  public:
   static void Destruct(const AsyncHandleWaiter::Context* context);
 };
 
 // The thread-safe part of |AsyncHandleWaiter|.
@@ skipping 56 matching lines @@
 
   // IOObserver implementation:
 
   void WillProcessIOEvent() override {
     DCHECK(io_loop_level_ != 0 || !should_invoke_callback_);
     DCHECK_GE(io_loop_level_, 0);
     io_loop_level_++;
   }
 
   void DidProcessIOEvent() override {
+    // This object could have been constructed in another's class's
+    // DidProcessIOEvent.
+    if (io_loop_level_== 0)
+      return;
+
     DCHECK_GE(io_loop_level_, 1);
 
     // Leaving a nested loop.
     if (io_loop_level_ > 1) {
       io_loop_level_--;
       return;
     }
 
     // The zero |waiter_| indicates that |this| have lost the owner and can be
     // under destruction. So we cannot wrap it with a |scoped_refptr| anymore.
@@ skipping 30 matching lines @@
     : callback_(callback),
       weak_factory_(this) {
   context_ = new Context(weak_factory_.GetWeakPtr());
 }
 
 AsyncHandleWaiter::~AsyncHandleWaiter() {
 }
 
 MojoResult AsyncHandleWaiter::Wait(MojoHandle handle,
                                    MojoHandleSignals signals) {
+#if defined(USE_CHROME_EDK)
+  return mojo::edk::AsyncWait(
+      handle, signals, base::Bind(&Context::HandleIsReady, context_));
+#else
   return mojo::embedder::AsyncWait(
       handle, signals, base::Bind(&Context::HandleIsReady, context_));
+#endif
 }
 
 void AsyncHandleWaiter::InvokeCallback(MojoResult result) {
   callback_.Run(result);
 }
 
 base::MessageLoopForIO::IOObserver* AsyncHandleWaiter::GetIOObserverForTest() {
   return context_.get();
 }
 
 base::Callback<void(MojoResult)> AsyncHandleWaiter::GetWaitCallbackForTest() {
   return base::Bind(&Context::HandleIsReady, context_);
 }
 
 // static
 void AsyncHandleWaiterContextTraits::Destruct(
     const AsyncHandleWaiter::Context* context) {
   context->io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&base::DeletePointer<const AsyncHandleWaiter::Context>,
                  base::Unretained(context)));
 }
 
 }  // namespace internal
 }  // namespace IPC