Add missing (and remove superfluous) 'explicit' from constructors.

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.
 //
 // Unit test for SyncChannel.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
@@ skipping 326 matching lines @@
         this, ipc_thread().message_loop_proxy(), shutdown_event());
     channel->Init(channel_name(), mode(), create_pipe_now_);
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 class TwoStepClient : public Worker {
  public:
-  TwoStepClient(bool create_pipe_now)
+  explicit TwoStepClient(bool create_pipe_now)
       : Worker(Channel::MODE_CLIENT, "simple_client"),
         create_pipe_now_(create_pipe_now) { }
 
   void OnAnswer(int* answer) {
     *answer = 42;
     Done();
   }
 
   virtual SyncChannel* CreateChannel() {
     SyncChannel* channel = new SyncChannel(
@@ skipping 882 matching lines @@
     sent_ping_event_->Signal();
   }
 
   void OnNoArgs() { }
   WaitableEvent* sent_ping_event_;
   WaitableEvent* wait_event_;
 };
 
 class NonRestrictedDispatchServer : public Worker {
  public:
-  NonRestrictedDispatchServer(WaitableEvent* signal_event)
+  explicit NonRestrictedDispatchServer(WaitableEvent* signal_event)
       : Worker("non_restricted_channel", Channel::MODE_SERVER),
         signal_event_(signal_event) {}
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
 
   void OnDoPingTTL(int ping) {
     int value = 0;
     Send(new SyncChannelTestMsg_PingTTL(ping, &value));
     signal_event_->Signal();
   }
@@ skipping 502 matching lines @@
 // behaves as a reply, not a regular message.
 // We have 3 workers. Server1 will send a message to Server2 (which will block),
 // 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.
 
 namespace {
 
 class ReentrantReplyServer1 : public Worker {
  public:
-  ReentrantReplyServer1(WaitableEvent* server_ready)
+  explicit ReentrantReplyServer1(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_SERVER),
         server_ready_(server_ready) { }
 
   void Run() {
     server2_channel_.reset(new SyncChannel(
         "reentrant_reply2", Channel::MODE_CLIENT, this,
         ipc_thread().message_loop_proxy(), true, shutdown_event()));
     server_ready_->Signal();
     Message* msg = new SyncChannelTestMsg_Reentrant1();
     server2_channel_->Send(msg);
@@ skipping 53 matching lines @@
     reply->set_unblock(true);
     Send(reply);
     Done();
   }
 
   Message* reply_;
 };
 
 class ReentrantReplyClient : public Worker {
  public:
-  ReentrantReplyClient(WaitableEvent* server_ready)
+  explicit ReentrantReplyClient(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_CLIENT),
         server_ready_(server_ready) { }
 
   void Run() {
     server_ready_->Wait();
     Send(new SyncChannelTestMsg_Reentrant2());
     Done();
   }
 
  private:
@@ skipping 98 matching lines @@
 
 }  // namespace
 
 // 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 IPC