Remove SyncChannel::SendWithTimeout

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2012 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/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 47 matching lines @@
         is_shutdown_(false) {
   }
 
   virtual ~Worker() {
     // Shutdown() must be called before destruction.
     CHECK(is_shutdown_);
   }
   void AddRef() { }
   void Release() { }
   virtual bool Send(Message* msg) OVERRIDE { return channel_->Send(msg); }
-  bool SendWithTimeout(Message* msg, int timeout_ms) {
-    return channel_->SendWithTimeout(msg, timeout_ms);
-  }
   void WaitForChannelCreation() { channel_created_->Wait(); }
   void CloseChannel() {
     DCHECK(base::MessageLoop::current() == ListenerThread()->message_loop());
     channel_->Close();
   }
   void Start() {
     StartThread(&listener_thread_, base::MessageLoop::TYPE_DEFAULT);
     ListenerThread()->message_loop()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnStart, this));
   }
   void Shutdown() {
     // The IPC thread needs to outlive SyncChannel. We can't do this in
     // ~Worker(), since that'll reset the vtable pointer (to Worker's), which
     // may result in a race conditions. See http://crbug.com/25841.
     WaitableEvent listener_done(false, false), ipc_done(false, false);
     ListenerThread()->message_loop()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown1, this,
                               &listener_done, &ipc_done));
     listener_done.Wait();
     ipc_done.Wait();
     ipc_thread_.Stop();
     listener_thread_.Stop();
     is_shutdown_ = true;
   }
   void OverrideThread(base::Thread* overrided_thread) {
     DCHECK(overrided_thread_ == NULL);
     overrided_thread_ = overrided_thread;
   }
-  bool SendAnswerToLife(bool pump, int timeout, bool succeed) {
+  bool SendAnswerToLife(bool pump, bool succeed) {
     int answer = 0;
     SyncMessage* msg = new SyncChannelTestMsg_AnswerToLife(&answer);
     if (pump)
       msg->EnableMessagePumping();
-    bool result = SendWithTimeout(msg, timeout);
+    bool result = Send(msg);
     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);
@@ skipping 158 matching lines @@
 };
 
 //------------------------------------------------------------------------------
 
 class SimpleServer : public Worker {
  public:
   explicit SimpleServer(bool pump_during_send)
       : Worker(Channel::MODE_SERVER, "simpler_server"),
         pump_during_send_(pump_during_send) { }
   virtual void Run() OVERRIDE {
-    SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
+    SendAnswerToLife(pump_during_send_, true);
     Done();
   }
 
   bool pump_during_send_;
 };
 
 class SimpleClient : public Worker {
  public:
   SimpleClient() : Worker(Channel::MODE_CLIENT, "simple_client") { }
 
@@ skipping 21 matching lines @@
 // Worker classes which override how the sync channel is created to use the
 // two-step initialization (calling the lightweight constructor and then
 // ChannelProxy::Init separately) process.
 class TwoStepServer : public Worker {
  public:
   explicit TwoStepServer(bool create_pipe_now)
       : Worker(Channel::MODE_SERVER, "simpler_server"),
         create_pipe_now_(create_pipe_now) { }
 
   virtual void Run() OVERRIDE {
-    SendAnswerToLife(false, base::kNoTimeout, true);
+    SendAnswerToLife(false, true);
     Done();
   }
 
   virtual SyncChannel* CreateChannel() OVERRIDE {
     SyncChannel* channel = new SyncChannel(
         this, ipc_thread().message_loop_proxy().get(), shutdown_event());
     channel->Init(channel_name(), mode(), create_pipe_now_);
     return channel;
   }
 
@@ skipping 65 matching lines @@
 
 //------------------------------------------------------------------------------
 
 class NoHangServer : public Worker {
  public:
   NoHangServer(WaitableEvent* got_first_reply, bool pump_during_send)
       : Worker(Channel::MODE_SERVER, "no_hang_server"),
         got_first_reply_(got_first_reply),
         pump_during_send_(pump_during_send) { }
   virtual void Run() OVERRIDE {
-    SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
+    SendAnswerToLife(pump_during_send_, true);
     got_first_reply_->Signal();
 
-    SendAnswerToLife(pump_during_send_, base::kNoTimeout, false);
+    SendAnswerToLife(pump_during_send_, false);
     Done();
   }
 
   WaitableEvent* got_first_reply_;
   bool pump_during_send_;
 };
 
 class NoHangClient : public Worker {
  public:
   explicit NoHangClient(WaitableEvent* got_first_reply)
@@ skipping 38 matching lines @@
   virtual void Run() OVERRIDE {
     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);
+      SendAnswerToLife(pump_during_send_, true);
     }
     Done();
   }
 
   virtual void OnDoubleDelay(int in, Message* reply_msg) OVERRIDE {
     SyncChannelTestMsg_Double::WriteReplyParams(reply_msg, in * 2);
     Send(reply_msg);
     if (delete_during_send_)
       ResetChannel();
   }
@@ skipping 50 matching lines @@
       : Worker(Channel::MODE_SERVER, "recursive_server"),
         expected_send_result_(expected_send_result),
         pump_first_(pump_first), pump_second_(pump_second) {}
   virtual void Run() OVERRIDE {
     SendDouble(pump_first_, expected_send_result_);
     Done();
   }
 
   virtual void OnDouble(int in, int* out) OVERRIDE {
     *out = in * 2;
-    SendAnswerToLife(pump_second_, base::kNoTimeout, expected_send_result_);
+    SendAnswerToLife(pump_second_, expected_send_result_);
   }
 
   bool expected_send_result_, pump_first_, pump_second_;
 };
 
 class RecursiveClient : public Worker {
  public:
   RecursiveClient(bool pump_during_send, bool close_channel)
       : Worker(Channel::MODE_CLIENT, "recursive_client"),
         pump_during_send_(pump_during_send), close_channel_(close_channel) {}
@@ skipping 117 matching lines @@
   MultipleClient2(
     WaitableEvent* client1_msg_received, WaitableEvent* client1_can_reply,
     bool pump_during_send)
     : Worker("test_channel2", Channel::MODE_CLIENT),
       client1_msg_received_(client1_msg_received),
       client1_can_reply_(client1_can_reply),
       pump_during_send_(pump_during_send) { }
 
   virtual void Run() OVERRIDE {
     client1_msg_received_->Wait();
-    SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
+    SendAnswerToLife(pump_during_send_, true);
     client1_can_reply_->Signal();
     Done();
   }
 
  private:
   WaitableEvent *client1_msg_received_, *client1_can_reply_;
   bool pump_during_send_;
 };
 
 void Multiple(bool server_pump, bool client_pump) {
@@ skipping 179 matching lines @@
 // 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) {
   ChattyServer(false);
   ChattyServer(true);
 }
 
 //------------------------------------------------------------------------------
 
-class TimeoutServer : public Worker {
- public:
-  TimeoutServer(int timeout_ms,
-                std::vector<bool> timeout_seq,
-                bool pump_during_send)
-      : Worker(Channel::MODE_SERVER, "timeout_server"),
-        timeout_ms_(timeout_ms),
-        timeout_seq_(timeout_seq),
-        pump_during_send_(pump_during_send) {
-  }
-
-  virtual void Run() OVERRIDE {
-    for (std::vector<bool>::const_iterator iter = timeout_seq_.begin();
-         iter != timeout_seq_.end(); ++iter) {
-      SendAnswerToLife(pump_during_send_, timeout_ms_, !*iter);
-    }
-    Done();
-  }
-
- private:
-  int timeout_ms_;
-  std::vector<bool> timeout_seq_;
-  bool pump_during_send_;
-};
-
-class UnresponsiveClient : public Worker {
- public:
-  explicit UnresponsiveClient(std::vector<bool> timeout_seq)
-      : Worker(Channel::MODE_CLIENT, "unresponsive_client"),
-        timeout_seq_(timeout_seq) {
-  }
-
-  virtual void OnAnswerDelay(Message* reply_msg) OVERRIDE {
-    DCHECK(!timeout_seq_.empty());
-    if (!timeout_seq_[0]) {
-      SyncChannelTestMsg_AnswerToLife::WriteReplyParams(reply_msg, 42);
-      Send(reply_msg);
-    } else {
-      // Don't reply.
-      delete reply_msg;
-    }
-    timeout_seq_.erase(timeout_seq_.begin());
-    if (timeout_seq_.empty())
-      Done();
-  }
-
- private:
-  // Whether we should time-out or respond to the various messages we receive.
-  std::vector<bool> timeout_seq_;
-};
-
-void SendWithTimeoutOK(bool pump_during_send) {
-  std::vector<Worker*> workers;
-  std::vector<bool> timeout_seq;
-  timeout_seq.push_back(false);
-  timeout_seq.push_back(false);
-  timeout_seq.push_back(false);
-  workers.push_back(new TimeoutServer(5000, timeout_seq, pump_during_send));
-  workers.push_back(new SimpleClient());
-  RunTest(workers);
-}
-
-void SendWithTimeoutTimeout(bool pump_during_send) {
-  std::vector<Worker*> workers;
-  std::vector<bool> timeout_seq;
-  timeout_seq.push_back(true);
-  timeout_seq.push_back(false);
-  timeout_seq.push_back(false);
-  workers.push_back(new TimeoutServer(100, timeout_seq, pump_during_send));
-  workers.push_back(new UnresponsiveClient(timeout_seq));
-  RunTest(workers);
-}
-
-void SendWithTimeoutMixedOKAndTimeout(bool pump_during_send) {
-  std::vector<Worker*> workers;
-  std::vector<bool> timeout_seq;
-  timeout_seq.push_back(true);
-  timeout_seq.push_back(false);
-  timeout_seq.push_back(false);
-  timeout_seq.push_back(true);
-  timeout_seq.push_back(false);
-  workers.push_back(new TimeoutServer(100, timeout_seq, pump_during_send));
-  workers.push_back(new UnresponsiveClient(timeout_seq));
-  RunTest(workers);
-}
-
-// Tests that SendWithTimeout does not time-out if the response comes back fast
-// enough.
-TEST_F(IPCSyncChannelTest, SendWithTimeoutOK) {
-  SendWithTimeoutOK(false);
-  SendWithTimeoutOK(true);
-}
-
-// Tests that SendWithTimeout does time-out.
-TEST_F(IPCSyncChannelTest, SendWithTimeoutTimeout) {
-  SendWithTimeoutTimeout(false);
-  SendWithTimeoutTimeout(true);
-}
-
-// Sends some message that time-out and some that succeed.
-TEST_F(IPCSyncChannelTest, SendWithTimeoutMixedOKAndTimeout) {
-  SendWithTimeoutMixedOKAndTimeout(false);
-  SendWithTimeoutMixedOKAndTimeout(true);
-}
-
-//------------------------------------------------------------------------------
-
 void NestedCallback(Worker* server) {
   // Sleep a bit so that we wake up after the reply has been received.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(250));
-  server->SendAnswerToLife(true, base::kNoTimeout, true);
+  server->SendAnswerToLife(true, true);
 }
 
 bool timeout_occurred = false;
 
 void TimeoutCallback() {
   timeout_occurred = true;
 }
 
 class DoneEventRaceServer : public Worker {
  public:
   DoneEventRaceServer()
       : Worker(Channel::MODE_SERVER, "done_event_race_server") { }
 
   virtual void Run() OVERRIDE {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(&NestedCallback, this));
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&TimeoutCallback),
         base::TimeDelta::FromSeconds(9));
     // Even though we have a timeout on the Send, it will succeed since for this
     // bug, the reply message comes back and is deserialized, however the done
     // event wasn't set.  So we indirectly use the timeout task to notice if a
     // timeout occurred.
-    SendAnswerToLife(true, 10000, true);
+    SendAnswerToLife(true, true);
     DCHECK(!timeout_occurred);
     Done();
   }
 };
 
 // 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;
@@ skipping 866 matching lines @@
 }
 
 // Windows needs to send an out-of-band secret to verify the client end of the
 // channel. Test that we still connect correctly in that case.
 TEST_F(IPCSyncChannelTest, Verified) {
   Verified();
 }
 
 }  // namespace
 }  // namespace IPC