Standardize usage of virtual/override/final in ipc/

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 40 matching lines @@
         channel_created_(new WaitableEvent(false, false)),
         channel_name_(channel_name),
         mode_(mode),
         ipc_thread_((channel_name + "_ipc").c_str()),
         listener_thread_((channel_name + "_listener").c_str()),
         overrided_thread_(NULL),
         shutdown_event_(true, false),
         is_shutdown_(false) {
   }
 
-  virtual ~Worker() {
+  ~Worker() override {
     // Shutdown() must be called before destruction.
     CHECK(is_shutdown_);
   }
   void AddRef() { }
   void Release() { }
-  virtual bool Send(Message* msg) override { return channel_->Send(msg); }
+  bool Send(Message* msg) override { return channel_->Send(msg); }
   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));
   }
@@ skipping 115 matching lines @@
     listener_thread_.message_loop()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown2, this,
                               listener_event));
   }
 
   void OnListenerThreadShutdown2(WaitableEvent* listener_event) {
     base::RunLoop().RunUntilIdle();
     listener_event->Signal();
   }
 
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(Worker, message)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_Double, OnDoubleDelay)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_AnswerToLife,
                                      OnAnswerDelay)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelNestedTestMsg_String,
                                      OnNestedTestMsg)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
@@ skipping 53 matching lines @@
   base::MessageLoop message_loop_;
 };
 
 //------------------------------------------------------------------------------
 
 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 {
+  void Run() override {
     SendAnswerToLife(pump_during_send_, true);
     Done();
   }
 
   bool pump_during_send_;
 };
 
 class SimpleClient : public Worker {
  public:
   SimpleClient() : Worker(Channel::MODE_CLIENT, "simple_client") { }
 
-  virtual void OnAnswer(int* answer) override {
+  void OnAnswer(int* answer) override {
     *answer = 42;
     Done();
   }
 };
 
 void Simple(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new SimpleServer(pump_during_send));
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }
 
 // Tests basic synchronous call
 TEST_F(IPCSyncChannelTest, Simple) {
   Simple(false);
   Simple(true);
 }
 
 //------------------------------------------------------------------------------
 
 // 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 {
+  void Run() override {
     SendAnswerToLife(false, true);
     Done();
   }
 
-  virtual SyncChannel* CreateChannel() override {
+  SyncChannel* CreateChannel() override {
     SyncChannel* channel =
         SyncChannel::Create(channel_name(), mode(), this,
                             ipc_thread().message_loop_proxy().get(),
                             create_pipe_now_,
                             shutdown_event()).release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 class TwoStepClient : public Worker {
  public:
   TwoStepClient(bool create_pipe_now)
       : Worker(Channel::MODE_CLIENT, "simple_client"),
         create_pipe_now_(create_pipe_now) { }
 
-  virtual void OnAnswer(int* answer) override {
+  void OnAnswer(int* answer) override {
     *answer = 42;
     Done();
   }
 
-  virtual SyncChannel* CreateChannel() override {
+  SyncChannel* CreateChannel() override {
     SyncChannel* channel =
         SyncChannel::Create(channel_name(), mode(), this,
                             ipc_thread().message_loop_proxy().get(),
                             create_pipe_now_,
                             shutdown_event()).release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
@@ skipping 13 matching lines @@
   TwoStep(true, false);
   TwoStep(true, true);
 }
 
 //------------------------------------------------------------------------------
 
 class DelayClient : public Worker {
  public:
   DelayClient() : Worker(Channel::MODE_CLIENT, "delay_client") { }
 
-  virtual void OnAnswerDelay(Message* reply_msg) override {
+  void OnAnswerDelay(Message* reply_msg) override {
     SyncChannelTestMsg_AnswerToLife::WriteReplyParams(reply_msg, 42);
     Send(reply_msg);
     Done();
   }
 };
 
 void DelayReply(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new SimpleServer(pump_during_send));
   workers.push_back(new DelayClient());
   RunTest(workers);
 }
 
 // Tests that asynchronous replies work
 TEST_F(IPCSyncChannelTest, DelayReply) {
   DelayReply(false);
   DelayReply(true);
 }
 
 //------------------------------------------------------------------------------
 
 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 {
+  void Run() override {
     SendAnswerToLife(pump_during_send_, true);
     got_first_reply_->Signal();
 
     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)
     : Worker(Channel::MODE_CLIENT, "no_hang_client"),
       got_first_reply_(got_first_reply) { }
 
-  virtual void OnAnswerDelay(Message* reply_msg) override {
+  void OnAnswerDelay(Message* reply_msg) override {
     // Use the DELAY_REPLY macro so that we can force the reply to be sent
     // before this function returns (when the channel will be reset).
     SyncChannelTestMsg_AnswerToLife::WriteReplyParams(reply_msg, 42);
     Send(reply_msg);
     got_first_reply_->Wait();
     CloseChannel();
     Done();
   }
 
   WaitableEvent* got_first_reply_;
@@ skipping 14 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 class UnblockServer : public Worker {
  public:
   UnblockServer(bool pump_during_send, bool delete_during_send)
     : Worker(Channel::MODE_SERVER, "unblock_server"),
       pump_during_send_(pump_during_send),
       delete_during_send_(delete_during_send) { }
-  virtual void Run() override {
+  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_, true);
     }
     Done();
   }
 
-  virtual void OnDoubleDelay(int in, Message* reply_msg) override {
+  void OnDoubleDelay(int in, Message* reply_msg) override {
     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:
   explicit UnblockClient(bool pump_during_send)
     : Worker(Channel::MODE_CLIENT, "unblock_client"),
       pump_during_send_(pump_during_send) { }
 
-  virtual void OnAnswer(int* answer) override {
+  void OnAnswer(int* answer) override {
     SendDouble(pump_during_send_, true);
     *answer = 42;
     Done();
   }
 
   bool pump_during_send_;
 };
 
 void Unblock(bool server_pump, bool client_pump, bool delete_during_send) {
   std::vector<Worker*> workers;
@@ skipping 21 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 class RecursiveServer : public Worker {
  public:
   RecursiveServer(bool expected_send_result, bool pump_first, bool pump_second)
       : Worker(Channel::MODE_SERVER, "recursive_server"),
         expected_send_result_(expected_send_result),
         pump_first_(pump_first), pump_second_(pump_second) {}
-  virtual void Run() override {
+  void Run() override {
     SendDouble(pump_first_, expected_send_result_);
     Done();
   }
 
-  virtual void OnDouble(int in, int* out) override {
+  void OnDouble(int in, int* out) override {
     *out = in * 2;
     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) {}
 
-  virtual void OnDoubleDelay(int in, Message* reply_msg) override {
+  void OnDoubleDelay(int in, Message* reply_msg) override {
     SendDouble(pump_during_send_, !close_channel_);
     if (close_channel_) {
       delete reply_msg;
     } else {
       SyncChannelTestMsg_Double::WriteReplyParams(reply_msg, in * 2);
       Send(reply_msg);
     }
     Done();
   }
 
-  virtual void OnAnswerDelay(Message* reply_msg) override {
+  void OnAnswerDelay(Message* reply_msg) override {
     if (close_channel_) {
       delete reply_msg;
       CloseChannel();
     } else {
       SyncChannelTestMsg_AnswerToLife::WriteReplyParams(reply_msg, 42);
       Send(reply_msg);
     }
   }
 
   bool pump_during_send_, close_channel_;
@@ skipping 45 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 class MultipleServer1 : public Worker {
  public:
   explicit MultipleServer1(bool pump_during_send)
     : Worker("test_channel1", Channel::MODE_SERVER),
       pump_during_send_(pump_during_send) { }
 
-  virtual void Run() override {
+  void Run() override {
     SendDouble(pump_during_send_, true);
     Done();
   }
 
   bool pump_during_send_;
 };
 
 class MultipleClient1 : public Worker {
  public:
   MultipleClient1(WaitableEvent* client1_msg_received,
                   WaitableEvent* client1_can_reply) :
       Worker("test_channel1", Channel::MODE_CLIENT),
       client1_msg_received_(client1_msg_received),
       client1_can_reply_(client1_can_reply) { }
 
-  virtual void OnDouble(int in, int* out) override {
+  void OnDouble(int in, int* out) override {
     client1_msg_received_->Signal();
     *out = in * 2;
     client1_can_reply_->Wait();
     Done();
   }
 
  private:
   WaitableEvent *client1_msg_received_, *client1_can_reply_;
 };
 
 class MultipleServer2 : public Worker {
  public:
   MultipleServer2() : Worker("test_channel2", Channel::MODE_SERVER) { }
 
-  virtual void OnAnswer(int* result) override {
+  void OnAnswer(int* result) override {
     *result = 42;
     Done();
   }
 };
 
 class MultipleClient2 : public Worker {
  public:
   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 {
+  void Run() override {
     client1_msg_received_->Wait();
     SendAnswerToLife(pump_during_send_, true);
     client1_can_reply_->Signal();
     Done();
   }
 
  private:
   WaitableEvent *client1_msg_received_, *client1_can_reply_;
   bool pump_during_send_;
 };
@@ skipping 49 matching lines @@
 class QueuedReplyServer : public Worker {
  public:
   QueuedReplyServer(base::Thread* listener_thread,
                     const std::string& channel_name,
                     const std::string& reply_text)
       : Worker(channel_name, Channel::MODE_SERVER),
         reply_text_(reply_text) {
     Worker::OverrideThread(listener_thread);
   }
 
-  virtual void OnNestedTestMsg(Message* reply_msg) override {
+  void OnNestedTestMsg(Message* reply_msg) override {
     VLOG(1) << __FUNCTION__ << " Sending reply: " << reply_text_;
     SyncChannelNestedTestMsg_String::WriteReplyParams(reply_msg, reply_text_);
     Send(reply_msg);
     Done();
   }
 
  private:
   std::string reply_text_;
 };
 
 // The QueuedReplyClient class provides functionality to test the case where
 // multiple sync channels are in use on the same thread and they make nested
 // sync calls, i.e. while the first channel waits for a response it makes a
 // sync call on another channel.
 // The callstack should unwind correctly, i.e. the outermost call should
 // complete first, and so on.
 class QueuedReplyClient : public Worker {
  public:
   QueuedReplyClient(base::Thread* listener_thread,
                     const std::string& channel_name,
                     const std::string& expected_text,
                     bool pump_during_send)
       : Worker(channel_name, Channel::MODE_CLIENT),
         pump_during_send_(pump_during_send),
         expected_text_(expected_text) {
     Worker::OverrideThread(listener_thread);
   }
 
-  virtual void Run() override {
+  void Run() override {
     std::string response;
     SyncMessage* msg = new SyncChannelNestedTestMsg_String(&response);
     if (pump_during_send_)
       msg->EnableMessagePumping();
     bool result = Send(msg);
     DCHECK(result);
     DCHECK_EQ(response, expected_text_);
 
     VLOG(1) << __FUNCTION__ << " Received reply: " << response;
     Done();
@@ skipping 52 matching lines @@
   QueuedReply(true);
 }
 
 //------------------------------------------------------------------------------
 
 class ChattyClient : public Worker {
  public:
   ChattyClient() :
       Worker(Channel::MODE_CLIENT, "chatty_client") { }
 
-  virtual void OnAnswer(int* answer) override {
+  void OnAnswer(int* answer) override {
     // The PostMessage limit is 10k.  Send 20% more than that.
     const int kMessageLimit = 10000;
     const int kMessagesToSend = kMessageLimit * 120 / 100;
     for (int i = 0; i < kMessagesToSend; ++i) {
       if (!SendDouble(false, true))
         break;
     }
     *answer = 42;
     Done();
   }
@@ skipping 26 matching lines @@
 
 void TimeoutCallback() {
   timeout_occurred = true;
 }
 
 class DoneEventRaceServer : public Worker {
  public:
   DoneEventRaceServer()
       : Worker(Channel::MODE_SERVER, "done_event_race_server") { }
 
-  virtual void Run() override {
+  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.
@@ skipping 18 matching lines @@
 class TestSyncMessageFilter : public SyncMessageFilter {
  public:
   TestSyncMessageFilter(base::WaitableEvent* shutdown_event,
                         Worker* worker,
                         scoped_refptr<base::MessageLoopProxy> message_loop)
       : SyncMessageFilter(shutdown_event),
         worker_(worker),
         message_loop_(message_loop) {
   }
 
-  virtual void OnFilterAdded(Sender* sender) override {
+  void OnFilterAdded(Sender* sender) override {
     SyncMessageFilter::OnFilterAdded(sender);
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&TestSyncMessageFilter::SendMessageOnHelperThread, this));
   }
 
   void SendMessageOnHelperThread() {
     int answer = 0;
     bool result = Send(new SyncChannelTestMsg_AnswerToLife(&answer));
     DCHECK(result);
     DCHECK_EQ(answer, 42);
 
     worker_->Done();
   }
 
  private:
-  virtual ~TestSyncMessageFilter() {}
+  ~TestSyncMessageFilter() override {}
 
   Worker* worker_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 };
 
 class SyncMessageFilterServer : public Worker {
  public:
   SyncMessageFilterServer()
       : Worker(Channel::MODE_SERVER, "sync_message_filter_server"),
         thread_("helper_thread") {
     base::Thread::Options options;
     options.message_loop_type = base::MessageLoop::TYPE_DEFAULT;
     thread_.StartWithOptions(options);
     filter_ = new TestSyncMessageFilter(shutdown_event(), this,
                                         thread_.message_loop_proxy());
   }
 
-  virtual void Run() override {
+  void Run() override {
     channel()->AddFilter(filter_.get());
   }
 
   base::Thread thread_;
   scoped_refptr<TestSyncMessageFilter> filter_;
 };
 
 // This class provides functionality to test the case that a Send on the sync
 // channel does not crash after the channel has been closed.
 class ServerSendAfterClose : public Worker {
  public:
   ServerSendAfterClose()
      : Worker(Channel::MODE_SERVER, "simpler_server"),
        send_result_(true) {
   }
 
   bool SendDummy() {
     ListenerThread()->message_loop()->PostTask(
         FROM_HERE, base::Bind(base::IgnoreResult(&ServerSendAfterClose::Send),
                               this, new SyncChannelTestMsg_NoArgs));
     return true;
   }
 
   bool send_result() const {
     return send_result_;
   }
 
  private:
-  virtual void Run() override {
+  void Run() override {
     CloseChannel();
     Done();
   }
 
-  virtual bool Send(Message* msg) override {
+  bool Send(Message* msg) override {
     send_result_ = Worker::Send(msg);
     Done();
     return send_result_;
   }
 
   bool send_result_;
 };
 
 // Tests basic synchronous call
 TEST_F(IPCSyncChannelTest, SyncMessageFilter) {
@@ skipping 41 matching lines @@
   }
 
   void OnPingTTL(int ping, int* out) {
     *out = ping;
     wait_event_->Wait();
   }
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(RestrictedDispatchServer, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_NoArgs, OnNoArgs)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_PingTTL, OnPingTTL)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Done, Done)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnPingSent() {
     sent_ping_event_->Signal();
@@ skipping 12 matching lines @@
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
 
   void OnDoPingTTL(int ping) {
     int value = 0;
     Send(new SyncChannelTestMsg_PingTTL(ping, &value));
     signal_event_->Signal();
   }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(NonRestrictedDispatchServer, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_NoArgs, OnNoArgs)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Done, Done)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnNoArgs() { }
   WaitableEvent* signal_event_;
 };
 
 class RestrictedDispatchClient : public Worker {
  public:
   RestrictedDispatchClient(WaitableEvent* sent_ping_event,
                            RestrictedDispatchServer* server,
                            NonRestrictedDispatchServer* server2,
                            int* success)
       : Worker("restricted_channel", Channel::MODE_CLIENT),
         ping_(0),
         server_(server),
         server2_(server2),
         success_(success),
         sent_ping_event_(sent_ping_event) {}
 
-  virtual void Run() override {
+  void Run() override {
     // Incoming messages from our channel should only be dispatched when we
     // send a message on that same channel.
     channel()->SetRestrictDispatchChannelGroup(1);
 
     server_->ListenerThread()->message_loop()->PostTask(
         FROM_HERE, base::Bind(&RestrictedDispatchServer::OnDoPing, server_, 1));
     sent_ping_event_->Wait();
     Send(new SyncChannelTestMsg_NoArgs);
     if (ping_ == 1)
       ++*success_;
@@ skipping 43 matching lines @@
     else
       LOG(ERROR) << "Send failed to dispatch message from unrestricted channel";
 
     non_restricted_channel_->Send(new SyncChannelTestMsg_Done);
     non_restricted_channel_.reset();
     Send(new SyncChannelTestMsg_Done);
     Done();
   }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(RestrictedDispatchClient, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Ping, OnPing)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_PingTTL, OnPingTTL)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnPing(int ping) {
     ping_ = ping;
   }
@@ skipping 73 matching lines @@
         events_(events),
         peer_(peer) { }
 
   void OnDoServerTask() {
     events_[3]->Signal();
     events_[2]->Wait();
     events_[0]->Signal();
     SendMessageToClient();
   }
 
-  virtual void Run() override {
+  void Run() override {
     channel()->SetRestrictDispatchChannelGroup(1);
     server_ready_event_->Signal();
   }
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(RestrictedDispatchDeadlockServer, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_NoArgs, OnNoArgs)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Done, Done)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnNoArgs() {
     if (server_num_ == 1) {
       DCHECK(peer_ != NULL);
@@ skipping 19 matching lines @@
   RestrictedDispatchDeadlockClient2(RestrictedDispatchDeadlockServer* server,
                                     WaitableEvent* server_ready_event,
                                     WaitableEvent** events)
       : Worker("channel2", Channel::MODE_CLIENT),
         server_ready_event_(server_ready_event),
         events_(events),
         received_msg_(false),
         received_noarg_reply_(false),
         done_issued_(false) {}
 
-  virtual void Run() override {
+  void Run() override {
     server_ready_event_->Wait();
   }
 
   void OnDoClient2Task() {
     events_[3]->Wait();
     events_[1]->Signal();
     events_[2]->Signal();
     DCHECK(received_msg_ == false);
 
     Message* message = new SyncChannelTestMsg_NoArgs;
     message->set_unblock(true);
     Send(message);
     received_noarg_reply_ = true;
   }
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(RestrictedDispatchDeadlockClient2, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_NoArgs, OnNoArgs)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnNoArgs() {
     received_msg_ = true;
     PossiblyDone();
   }
@@ skipping 22 matching lines @@
                                     WaitableEvent** events)
       : Worker("channel1", Channel::MODE_CLIENT),
         server_(server),
         peer_(peer),
         server_ready_event_(server_ready_event),
         events_(events),
         received_msg_(false),
         received_noarg_reply_(false),
         done_issued_(false) {}
 
-  virtual void Run() override {
+  void Run() override {
     server_ready_event_->Wait();
     server_->ListenerThread()->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&RestrictedDispatchDeadlockServer::OnDoServerTask, server_));
     peer_->ListenerThread()->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&RestrictedDispatchDeadlockClient2::OnDoClient2Task, peer_));
     events_[0]->Wait();
     events_[1]->Wait();
     DCHECK(received_msg_ == false);
 
     Message* message = new SyncChannelTestMsg_NoArgs;
     message->set_unblock(true);
     Send(message);
     received_noarg_reply_ = true;
     PossiblyDone();
   }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(RestrictedDispatchDeadlockClient1, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_NoArgs, OnNoArgs)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnNoArgs() {
     received_msg_ = true;
     PossiblyDone();
   }
@@ skipping 92 matching lines @@
   }
 
   void OnDone() {
     if (is_first())
       return;
     other_channel_->Send(new SyncChannelTestMsg_Done);
     other_channel_.reset();
     Done();
   }
 
-  virtual void Run() override {
+  void Run() override {
     channel()->SetRestrictDispatchChannelGroup(group_);
     if (is_first())
       event1_->Signal();
     event2_->Wait();
     other_channel_ =
         SyncChannel::Create(other_channel_name_,
                             IPC::Channel::MODE_CLIENT,
                             this,
                             ipc_thread().message_loop_proxy().get(),
                             true,
@@ skipping 12 matching lines @@
     OnPingTTL(5, &value);
     *success_ += (value == 5);
     other_channel_->Send(new SyncChannelTestMsg_Done);
     other_channel_.reset();
     Done();
   }
 
   bool is_first() { return !!success_; }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(RestrictedDispatchPipeWorker, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_PingTTL, OnPingTTL)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Done, OnDone)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   scoped_ptr<SyncChannel> other_channel_;
   WaitableEvent* event1_;
   WaitableEvent* event2_;
@@ skipping 30 matching lines @@
 // during which it will dispatch a message comming from Client, at which point
 // it will send another message to Server2. While sending that second message it
 // will receive a reply from Server1 with the unblock flag.
 
 class ReentrantReplyServer1 : public Worker {
  public:
   ReentrantReplyServer1(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_SERVER),
         server_ready_(server_ready) { }
 
-  virtual void Run() override {
+  void Run() override {
     server2_channel_ =
         SyncChannel::Create("reentrant_reply2",
                             IPC::Channel::MODE_CLIENT,
                             this,
                             ipc_thread().message_loop_proxy().get(),
                             true,
                             shutdown_event());
     server_ready_->Signal();
     Message* msg = new SyncChannelTestMsg_Reentrant1();
     server2_channel_->Send(msg);
     server2_channel_.reset();
     Done();
   }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(ReentrantReplyServer1, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Reentrant2, OnReentrant2)
      IPC_REPLY_HANDLER(OnReply)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnReentrant2() {
     Message* msg = new SyncChannelTestMsg_Reentrant3();
     server2_channel_->Send(msg);
   }
 
   void OnReply(const Message& message) {
     // If we get here, the Send() will never receive the reply (thus would
     // hang), so abort instead.
     LOG(FATAL) << "Reply message was dispatched";
   }
 
   WaitableEvent* server_ready_;
   scoped_ptr<SyncChannel> server2_channel_;
 };
 
 class ReentrantReplyServer2 : public Worker {
  public:
   ReentrantReplyServer2()
       : Worker("reentrant_reply2", Channel::MODE_SERVER),
         reply_(NULL) { }
 
  private:
-  virtual bool OnMessageReceived(const Message& message) override {
+  bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(ReentrantReplyServer2, message)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(
          SyncChannelTestMsg_Reentrant1, OnReentrant1)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Reentrant3, OnReentrant3)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   void OnReentrant1(Message* reply) {
     DCHECK(!reply_);
@@ skipping 11 matching lines @@
 
   Message* reply_;
 };
 
 class ReentrantReplyClient : public Worker {
  public:
   ReentrantReplyClient(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_CLIENT),
         server_ready_(server_ready) { }
 
-  virtual void Run() override {
+  void Run() override {
     server_ready_->Wait();
     Send(new SyncChannelTestMsg_Reentrant2());
     Done();
   }
 
  private:
   WaitableEvent* server_ready_;
 };
 
 TEST_F(IPCSyncChannelTest, ReentrantReply) {
@@ skipping 12 matching lines @@
 class VerifiedServer : public Worker {
  public:
   VerifiedServer(base::Thread* listener_thread,
                  const std::string& channel_name,
                  const std::string& reply_text)
       : Worker(channel_name, Channel::MODE_SERVER),
         reply_text_(reply_text) {
     Worker::OverrideThread(listener_thread);
   }
 
-  virtual void OnNestedTestMsg(Message* reply_msg) override {
+  void OnNestedTestMsg(Message* reply_msg) override {
     VLOG(1) << __FUNCTION__ << " Sending reply: " << reply_text_;
     SyncChannelNestedTestMsg_String::WriteReplyParams(reply_msg, reply_text_);
     Send(reply_msg);
     ASSERT_EQ(channel()->GetPeerPID(), base::GetCurrentProcId());
     Done();
   }
 
  private:
   std::string reply_text_;
 };
 
 class VerifiedClient : public Worker {
  public:
   VerifiedClient(base::Thread* listener_thread,
                  const std::string& channel_name,
                  const std::string& expected_text)
       : Worker(channel_name, Channel::MODE_CLIENT),
         expected_text_(expected_text) {
     Worker::OverrideThread(listener_thread);
   }
 
-  virtual void Run() override {
+  void Run() override {
     std::string response;
     SyncMessage* msg = new SyncChannelNestedTestMsg_String(&response);
     bool result = Send(msg);
     DCHECK(result);
     DCHECK_EQ(response, expected_text_);
     // expected_text_ is only used in the above DCHECK. This line suppresses the
     // "unused private field" warning in release builds.
     (void)expected_text_;
 
     VLOG(1) << __FUNCTION__ << " Received reply: " << response;
@@ skipping 32 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