WIP: A couple of more ChannelMojo speedup ideas

ipc/mojo/async_handle_waiter_unittest.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/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/mojo/src/mojo/public/cpp/system/message_pipe.h"
 
 namespace IPC {
 namespace internal {
 namespace {
 
 void ReadOneByteOfX(MojoHandle pipe) {
   uint32_t size = 1;
   char buffer = ' ';
   MojoResult rv = MojoReadMessage(pipe, &buffer, &size, nullptr, nullptr,
                                   MOJO_READ_MESSAGE_FLAG_NONE);
   CHECK_EQ(rv, MOJO_RESULT_OK);
   CHECK_EQ(size, 1U);
   CHECK_EQ(buffer, 'X');
 }
 
-class AsyncHandleWaiterTest : public testing::Test {
+class AsyncHandleWaiterTest : public testing::Test,
+                              public AsyncHandleWaiter::Delegate {
  public:
   AsyncHandleWaiterTest() : worker_("test_worker") {
     worker_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   }
 
   void SetUp() override {
     message_loop_.reset(new base::MessageLoopForIO());
     ResetSignaledStates();
     mojo::CreateMessagePipe(nullptr, &pipe_to_write_, &pipe_to_read_);
-    target_.reset(new AsyncHandleWaiter(base::Bind(
-        &AsyncHandleWaiterTest::HandleIsReady, base::Unretained(this))));
+    target_.reset(new AsyncHandleWaiter(this));
   }
 
  protected:
   MojoResult Start() {
     return target_->Wait(pipe_to_read_.get().value(),
                          MOJO_HANDLE_SIGNAL_READABLE);
   }
 
   void ResetSignaledStates() {
     signaled_result_ = MOJO_RESULT_UNKNOWN;
@@ skipping 20 matching lines @@
   }
 
   void WaitAndAssertNotSignaled() {
     run_loop_->RunUntilIdle();
     EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe_to_read_.get().value(),
                                        MOJO_HANDLE_SIGNAL_READABLE, 0,
                                        nullptr));
     EXPECT_EQ(MOJO_RESULT_UNKNOWN, signaled_result_);
   }
 
-  void HandleIsReady(MojoResult result) {
+  void MessageWasArrived(const void* bytes, uint32_t num_bytes) override {
+    EXPECT_TRUE(false);
+  }
+
+  void PipeIsReady(MojoResult result) override {
     CHECK_EQ(base::MessageLoop::current(), message_loop_.get());
     CHECK_EQ(signaled_result_, MOJO_RESULT_UNKNOWN);
     signaled_result_ = result;
     run_loop_->Quit();
   }
 
   base::Thread worker_;
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
   mojo::ScopedMessagePipeHandle pipe_to_write_;
@@ skipping 40 matching lines @@
 
 TEST_F(AsyncHandleWaiterTest, DeleteWaiterBeforeSignal) {
   EXPECT_EQ(MOJO_RESULT_OK, Start());
   WriteToPipe();
 
   target_.reset();
 
   WaitAndAssertNotSignaled();
 }
 
-class HandlerThatReenters {
+class HandlerThatReenters : public AsyncHandleWaiter::Delegate {
  public:
   HandlerThatReenters(base::RunLoop* loop, MojoHandle handle)
       : target_(nullptr), handle_(handle), loop_(loop), step_(0) {}
 
   void set_target(AsyncHandleWaiter* target) { target_ = target; }
 
-  void HandleIsReady(MojoResult result) {
+  void MessageWasArrived(const void* bytes, uint32_t num_bytes) override {
+    CHECK(false);
+  }
+
+  void PipeIsReady(MojoResult result) override {
     switch (step_) {
       case 0:
         RestartAndClose(result);
         break;
       case 1:
         HandleClosingSignal(result);
         break;
       default:
         NOTREACHED();
         break;
@@ skipping 23 matching lines @@
   bool IsClosingHandled() const { return step_ == 2; }
 
   AsyncHandleWaiter* target_;
   MojoHandle handle_;
   base::RunLoop* loop_;
   int step_;
 };
 
 TEST_F(AsyncHandleWaiterTest, RestartWaitingWhileSignaled) {
   HandlerThatReenters handler(run_loop_.get(), pipe_to_read_.get().value());
-  target_.reset(new AsyncHandleWaiter(base::Bind(
-      &HandlerThatReenters::HandleIsReady, base::Unretained(&handler))));
+  target_.reset(new AsyncHandleWaiter(&handler));
   handler.set_target(target_.get());
 
   EXPECT_EQ(MOJO_RESULT_OK, Start());
   WriteToPipe();
   run_loop_->Run();
 
   EXPECT_TRUE(handler.IsClosingHandled());
 
   // |HandlerThatReenters::RestartAndClose| already closed it.
   ignore_result(pipe_to_read_.release());
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace IPC