Don't use any member variables when sending a sync call...

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2006-2008 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.
 //
 // Unit test for SyncChannel.
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 86 matching lines @@
   void OverrideThread(base::Thread* overrided_thread) {
     DCHECK(overrided_thread_ == NULL);
     overrided_thread_ = overrided_thread;
   }
   bool SendAnswerToLife(bool pump, int timeout, bool succeed) {
     int answer = 0;
     SyncMessage* msg = new SyncChannelTestMsg_AnswerToLife(&answer);
     if (pump)
       msg->EnableMessagePumping();
     bool result = SendWithTimeout(msg, timeout);
-    DCHECK(result == succeed);
-    DCHECK(answer == (succeed ? 42 : 0));
+    DCHECK_EQ(result, succeed);
+    DCHECK_EQ(answer, (succeed ? 42 : 0));
     return result;
   }
   bool SendDouble(bool pump, bool succeed) {
     int answer = 0;
     SyncMessage* msg = new SyncChannelTestMsg_Double(5, &answer);
     if (pump)
       msg->EnableMessagePumping();
     bool result = Send(msg);
-    DCHECK(result == succeed);
-    DCHECK(answer == (succeed ? 10 : 0));
+    DCHECK_EQ(result, succeed);
+    DCHECK_EQ(answer, (succeed ? 10 : 0));
     return result;
   }
   Channel::Mode mode() { return mode_; }
   WaitableEvent* done_event() { return done_.get(); }
+  void ResetChannel() { channel_.reset(); }
 
  protected:
   // Derived classes need to call this when they've completed their part of
   // the test.
   void Done() { done_->Signal(); }
   // Functions for dervied classes to implement if they wish.
   virtual void Run() { }
   virtual void OnAnswer(int* answer) { NOTREACHED(); }
   virtual void OnAnswerDelay(Message* reply_msg) {
     // The message handler map below can only take one entry for
@@ skipping 249 matching lines @@
   NoHang(false);
   NoHang(true);
 }
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 class UnblockServer : public Worker {
  public:
-  UnblockServer(bool pump_during_send)
+  UnblockServer(bool pump_during_send, bool delete_during_send)
     : Worker(Channel::MODE_SERVER, "unblock_server"),
-      pump_during_send_(pump_during_send) { }
+      pump_during_send_(pump_during_send),
+      delete_during_send_(delete_during_send) { }
   void Run() {
-    SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
+    if (delete_during_send_) {
+      // Use custom code since race conditions mean the answer may or may not be
+      // available.
+      int answer = 0;
+      SyncMessage* msg = new SyncChannelTestMsg_AnswerToLife(&answer);
+      if (pump_during_send_)
+        msg->EnableMessagePumping();
+      Send(msg);
+    } else {
+      SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
+    }
     Done();
   }
 
-  void OnDouble(int in, int* out) {
-    *out = in * 2;
+  void OnDoubleDelay(int in, Message* reply_msg) {
+    SyncChannelTestMsg_Double::WriteReplyParams(reply_msg, in * 2);
+    Send(reply_msg);
+    if (delete_during_send_)
+      ResetChannel();
   }
 
   bool pump_during_send_;
+  bool delete_during_send_;
 };
 
 class UnblockClient : public Worker {
  public:
   UnblockClient(bool pump_during_send)
     : Worker(Channel::MODE_CLIENT, "unblock_client"),
       pump_during_send_(pump_during_send) { }
 
   void OnAnswer(int* answer) {
     SendDouble(pump_during_send_, true);
     *answer = 42;
     Done();
   }
 
   bool pump_during_send_;
 };
 
-void Unblock(bool server_pump, bool client_pump) {
+void Unblock(bool server_pump, bool client_pump, bool delete_during_send) {
   std::vector<Worker*> workers;
-  workers.push_back(new UnblockServer(server_pump));
+  workers.push_back(new UnblockServer(server_pump, delete_during_send));
   workers.push_back(new UnblockClient(client_pump));
   RunTest(workers);
 }
 
 }  // namespace
 
 // Tests that the caller unblocks to answer a sync message from the receiver.
 TEST_F(IPCSyncChannelTest, Unblock) {
-  Unblock(false, false);
-  Unblock(false, true);
-  Unblock(true, false);
-  Unblock(true, true);
+  Unblock(false, false, false);
+  Unblock(false, true, false);
+  Unblock(true, false, false);
+  Unblock(true, true, false);
+}
+
+//-----------------------------------------------------------------------------
+
+// Tests that the the IPC::SyncChannel object can be deleted during a Send.
+TEST_F(IPCSyncChannelTest, ChannelDeleteDuringSend) {
+  Unblock(false, false, true);
+  Unblock(false, true, true);
+  Unblock(true, false, true);
+  Unblock(true, true, true);
 }
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 class RecursiveServer : public Worker {
  public:
   explicit RecursiveServer(
     bool expected_send_result, bool pump_first, bool pump_second)
@@ skipping 256 matching lines @@
     Worker::OverrideThread(listener_thread);
   }
 
   virtual void Run() {
     std::string response;
     SyncMessage* msg = new SyncChannelNestedTestMsg_String(&response);
     if (pump_during_send_)
       msg->EnableMessagePumping();
     bool result = Send(msg);
     DCHECK(result);
-    DCHECK(response == expected_text_);
+    DCHECK_EQ(response, expected_text_);
 
     LOG(INFO) << __FUNCTION__ << " Received reply: "
               << response.c_str();
     Done();
   }
 
  private:
   bool pump_during_send_;
   std::string expected_text_;
 };
@@ skipping 70 matching lines @@
     // in ipc_message_utils doesn't fire.
     int log_level = logging::GetMinLogLevel();
     logging::SetMinLogLevel(kint32max);
     bool result = Send(msg);
     logging::SetMinLogLevel(log_level);
     DCHECK(!result);
 
     // Need to send another message to get the client to call Done().
     result = Send(new SyncChannelTestMsg_AnswerToLife(&answer));
     DCHECK(result);
-    DCHECK(answer == 42);
+    DCHECK_EQ(answer, 42);
 
     Done();
   }
 
   bool pump_during_send_;
 };
 
 void BadMessage(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new BadServer(pump_during_send));
@@ skipping 26 matching lines @@
       if (!SendDouble(false, true))
         break;
     }
     *answer = 42;
     Done();
   }
 };
 
 void ChattyServer(bool pump_during_send) {
   std::vector<Worker*> workers;
-  workers.push_back(new UnblockServer(pump_during_send));
+  workers.push_back(new UnblockServer(pump_during_send, false));
   workers.push_back(new ChattyClient());
   RunTest(workers);
 }
 
 }  // namespace
 
 // Tests http://b/1093251 - that sending lots of sync messages while
 // the receiver is waiting for a sync reply does not overflow the PostMessage
 // queue.
 TEST_F(IPCSyncChannelTest, ChattyServer) {
@@ skipping 159 matching lines @@
 
 // Tests http://b/1474092 - that if after the done_event is set but before
 // OnObjectSignaled is called another message is sent out, then after its
 // reply comes back OnObjectSignaled will be called for the first message.
 TEST_F(IPCSyncChannelTest, DoneEventRace) {
   std::vector<Worker*> workers;
   workers.push_back(new DoneEventRaceServer());
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }