Allow mojo::system::RawChannel::Delegate methods to destroy the RawChannel.

mojo/edk/system/raw_channel_unittest.cc

 // Copyright 2014 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/raw_channel.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
 #include <vector>
@@ skipping 537 matching lines @@
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass()));
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate)));
   io_thread()->PostTaskAndWait(
       FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc.get())));
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 }
 
-// RawChannelTest.ShutdownOnReadMessage ----------------------------------------
+// RawChannelTest.{Shutdown, ShutdownAndDestroy}OnReadMessage ------------------
 
 class ShutdownOnReadMessageRawChannelDelegate : public RawChannel::Delegate {
  public:
-  explicit ShutdownOnReadMessageRawChannelDelegate(RawChannel* raw_channel)
+  explicit ShutdownOnReadMessageRawChannelDelegate(RawChannel* raw_channel,
+                                                   bool should_destroy)
       : raw_channel_(raw_channel),
+        should_destroy_(should_destroy),
         done_event_(false, false),
         did_shutdown_(false) {}
   ~ShutdownOnReadMessageRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   void OnReadMessage(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
     EXPECT_FALSE(platform_handles);
     EXPECT_FALSE(did_shutdown_);
     EXPECT_TRUE(
         CheckMessageData(message_view.bytes(), message_view.num_bytes()));
     raw_channel_->Shutdown();
+    if (should_destroy_)
+      delete raw_channel_;
     did_shutdown_ = true;
     done_event_.Signal();
   }
   void OnError(Error /*error*/) override {
     CHECK(false);  // Should not get called.
   }
 
   // Waits for shutdown.
   void Wait() {
     done_event_.Wait();
     EXPECT_TRUE(did_shutdown_);
   }
 
  private:
   RawChannel* const raw_channel_;
+  const bool should_destroy_;
   base::WaitableEvent done_event_;
   bool did_shutdown_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownOnReadMessageRawChannelDelegate);
 };
 
 TEST_F(RawChannelTest, ShutdownOnReadMessage) {
   // Write a few messages into the other end.
   for (size_t count = 0; count < 5; count++)
     EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), 10));
 
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass()));
-  ShutdownOnReadMessageRawChannelDelegate delegate(rc.get());
+  ShutdownOnReadMessageRawChannelDelegate delegate(rc.get(), false);
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate)));
 
   // Wait for the delegate, which will shut the |RawChannel| down.
   delegate.Wait();
 }
 
-// RawChannelTest.ShutdownOnError{Read, Write} ---------------------------------
+TEST_F(RawChannelTest, ShutdownAndDestroyOnReadMessage) {

[yzshen1, 2015/01/21 23:03:42]

An alternative is to use value parameterized tests (TEST_P). That might reduce
some redundency.

[viettrungluu, 2015/01/21 23:34:32]

I don't think it's worth the extra complication (test fixture, more
conditionals) for something so small....

+  // Write a message into the other end.
+  EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), 10));
+
+  // The delegate will destroy |rc|.
+  RawChannel* rc = RawChannel::Create(handles[0].Pass()).release();
+  ShutdownOnReadMessageRawChannelDelegate delegate(rc, true);
+  io_thread()->PostTaskAndWait(
+      FROM_HERE, base::Bind(&InitOnIOThread, rc, base::Unretained(&delegate)));
+
+  // Wait for the delegate, which will shut the |RawChannel| down.
+  delegate.Wait();
+}
+
+// RawChannelTest.{Shutdown, ShutdownAndDestroy}OnError{Read, Write} -----------
 
 class ShutdownOnErrorRawChannelDelegate : public RawChannel::Delegate {
  public:
   ShutdownOnErrorRawChannelDelegate(RawChannel* raw_channel,
+                                    bool should_destroy,
                                     Error shutdown_on_error_type)
       : raw_channel_(raw_channel),
+        should_destroy_(should_destroy),
         shutdown_on_error_type_(shutdown_on_error_type),
         done_event_(false, false),
         did_shutdown_(false) {}
   ~ShutdownOnErrorRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   void OnReadMessage(
       const MessageInTransit::View& /*message_view*/,
       embedder::ScopedPlatformHandleVectorPtr /*platform_handles*/) override {
     CHECK(false);  // Should not get called.
   }
   void OnError(Error error) override {
     EXPECT_FALSE(did_shutdown_);
     if (error != shutdown_on_error_type_)
       return;
     raw_channel_->Shutdown();
+    if (should_destroy_)
+      delete raw_channel_;
     did_shutdown_ = true;
     done_event_.Signal();
   }
 
   // Waits for shutdown.
   void Wait() {
     done_event_.Wait();
     EXPECT_TRUE(did_shutdown_);
   }
 
  private:
   RawChannel* const raw_channel_;
+  const bool should_destroy_;
   const Error shutdown_on_error_type_;
   base::WaitableEvent done_event_;
   bool did_shutdown_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownOnErrorRawChannelDelegate);
 };
 
 TEST_F(RawChannelTest, ShutdownOnErrorRead) {
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass()));
   ShutdownOnErrorRawChannelDelegate delegate(
-      rc.get(), RawChannel::Delegate::ERROR_READ_SHUTDOWN);
+      rc.get(), false, RawChannel::Delegate::ERROR_READ_SHUTDOWN);
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate)));
 
   // Close the handle of the other end, which should stuff fail.
   handles[1].reset();
 
   // Wait for the delegate, which will shut the |RawChannel| down.
   delegate.Wait();
 }
 
+TEST_F(RawChannelTest, ShutdownAndDestroyOnErrorRead) {
+  RawChannel* rc = RawChannel::Create(handles[0].Pass()).release();
+  ShutdownOnErrorRawChannelDelegate delegate(
+      rc, true, RawChannel::Delegate::ERROR_READ_SHUTDOWN);
+  io_thread()->PostTaskAndWait(
+      FROM_HERE, base::Bind(&InitOnIOThread, rc, base::Unretained(&delegate)));
+
+  // Close the handle of the other end, which should stuff fail.
+  handles[1].reset();
+
+  // Wait for the delegate, which will shut the |RawChannel| down.
+  delegate.Wait();
+}
+
 TEST_F(RawChannelTest, ShutdownOnErrorWrite) {
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass()));
-  ShutdownOnErrorRawChannelDelegate delegate(rc.get(),
+  ShutdownOnErrorRawChannelDelegate delegate(rc.get(), false,
                                              RawChannel::Delegate::ERROR_WRITE);
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate)));
 
   // Close the handle of the other end, which should stuff fail.
   handles[1].reset();
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 
   // Wait for the delegate, which will shut the |RawChannel| down.
   delegate.Wait();
 }
 
+TEST_F(RawChannelTest, ShutdownAndDestroyOnErrorWrite) {
+  RawChannel* rc = RawChannel::Create(handles[0].Pass()).release();
+  ShutdownOnErrorRawChannelDelegate delegate(rc, true,
+                                             RawChannel::Delegate::ERROR_WRITE);
+  io_thread()->PostTaskAndWait(
+      FROM_HERE, base::Bind(&InitOnIOThread, rc, base::Unretained(&delegate)));
+
+  // Close the handle of the other end, which should stuff fail.
+  handles[1].reset();
+
+  EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
+
+  // Wait for the delegate, which will shut the |RawChannel| down.
+  delegate.Wait();
+}
+
 // RawChannelTest.ReadWritePlatformHandles -------------------------------------
 
 class ReadPlatformHandlesCheckerRawChannelDelegate
     : public RawChannel::Delegate {
  public:
   ReadPlatformHandlesCheckerRawChannelDelegate() : done_event_(false, false) {}
   ~ReadPlatformHandlesCheckerRawChannelDelegate() override {}
 
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   void OnReadMessage(
@@ skipping 99 matching lines @@
       FROM_HERE,
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_read.get())));
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_write.get())));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo