Mojo: Add BindingsSupportImpl on top of HandleWatcher

mojo/common/handle_watcher_unittest.cc

 // Copyright 2013 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/common/handle_watcher.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 14 matching lines @@
   uint32_t num_handles = 0;
   return MojoReadMessage(handle, NULL, &num_bytes, NULL, &num_handles,
                          MOJO_READ_MESSAGE_FLAG_MAY_DISCARD);
 }
 
 void RunUntilIdle() {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 }
 
+void DeleteWatcherAndForwardResult(
+    HandleWatcher* watcher,
+    base::Callback<void(MojoResult)> next_callback,
+    MojoResult result) {
+  delete watcher;
+  next_callback.Run(result);
+}
+
 // Helper class to manage the callback and running the message loop waiting for
 // message to be received. Typical usage is something like:
 //   Schedule callback returned from GetCallback().
 //   RunUntilGotCallback();
 //   EXPECT_TRUE(got_callback());
 //   clear_callback();
 class CallbackHelper {
  public:
   CallbackHelper()
       : got_callback_(false),
         run_loop_(NULL),
         weak_factory_(this) {}
   ~CallbackHelper() {}
 
   // See description above |got_callback_|.
   bool got_callback() const { return got_callback_; }
   void clear_callback() { got_callback_ = false; }
 
   // Runs the current MessageLoop until the callback returned from GetCallback()
   // is notified.
   void RunUntilGotCallback() {
     ASSERT_TRUE(run_loop_ == NULL);
     base::RunLoop run_loop;
     base::AutoReset<base::RunLoop*> reseter(&run_loop_, &run_loop);
     run_loop.Run();
   }
 
-  base::Closure GetCallback() {
+  base::Callback<void(MojoResult)> GetCallback() {
     return base::Bind(&CallbackHelper::OnCallback, weak_factory_.GetWeakPtr());
   }
 
   void Start(HandleWatcher* watcher, MojoHandle handle) {
+    StartWithCallback(watcher, handle, GetCallback());
+  }
+
+  void StartWithCallback(HandleWatcher* watcher, MojoHandle handle,
+                         const base::Callback<void(MojoResult)>& callback) {
     watcher->Start(handle, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE,
-                   GetCallback());
+                   callback);
   }
 
  private:
-  void OnCallback() {
+  void OnCallback(MojoResult result) {
     got_callback_ = true;
     if (run_loop_)
       run_loop_->Quit();
   }
 
   // Set to true when the callback is called.
   bool got_callback_;
 
   // If non-NULL we're in RunUntilGotCallback().
   base::RunLoop* run_loop_;
@@ skipping 185 matching lines @@
 
   HandleWatcher watcher3;
   callback_helper3.Start(&watcher3, test_pipe3.handle_0());
 
   callback_helper2.RunUntilGotCallback();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_TRUE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 }
 
+TEST_F(HandleWatcherTest, DeleteInCallback) {
+  ScopedMessagePipe test_pipe;
+  CallbackHelper callback_helper;
+
+  HandleWatcher* watcher = new HandleWatcher();
+  callback_helper.StartWithCallback(watcher, test_pipe.handle_1(),
+                                    base::Bind(&DeleteWatcherAndForwardResult,
+                                               watcher,
+                                               callback_helper.GetCallback()));
+  WriteToHandle(test_pipe.handle_0());
+  callback_helper.RunUntilGotCallback();
+  EXPECT_TRUE(callback_helper.got_callback());
+}
+
 }  // namespace test
 }  // namespace common
 }  // namespace mojo