Remove explicit keyword from multi-argument constructors

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2011 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 322 matching lines @@
   DelayReply(false);
   DelayReply(true);
 }
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 class NoHangServer : public Worker {
  public:
-  explicit NoHangServer(WaitableEvent* got_first_reply, bool pump_during_send)
+  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) { }
   void Run() {
     SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
     got_first_reply_->Signal();
 
     SendAnswerToLife(pump_during_send_, base::kNoTimeout, false);
     Done();
   }
@@ skipping 114 matching lines @@
   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)
-    : Worker(Channel::MODE_SERVER, "recursive_server"),
-      expected_send_result_(expected_send_result),
-      pump_first_(pump_first), pump_second_(pump_second)  { }
+  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) {}
   void Run() {
     SendDouble(pump_first_, expected_send_result_);
     Done();
   }
 
   void OnDouble(int in, int* out) {
     *out = in * 2;
     SendAnswerToLife(pump_second_, base::kNoTimeout, expected_send_result_);
   }
 
   bool expected_send_result_, pump_first_, pump_second_;
 };
 
 class RecursiveClient : public Worker {
  public:
-  explicit RecursiveClient(bool pump_during_send, bool close_channel)
-    : Worker(Channel::MODE_CLIENT, "recursive_client"),
-      pump_during_send_(pump_during_send), close_channel_(close_channel) { }
+  RecursiveClient(bool pump_during_send, bool close_channel)
+      : Worker(Channel::MODE_CLIENT, "recursive_client"),
+        pump_during_send_(pump_during_send), close_channel_(close_channel) {}
 
   void OnDoubleDelay(int in, Message* reply_msg) {
     SendDouble(pump_during_send_, !close_channel_);
     if (close_channel_) {
       delete reply_msg;
     } else {
       SyncChannelTestMsg_Double::WriteReplyParams(reply_msg, in * 2);
       Send(reply_msg);
     }
     Done();
@@ skipping 441 matching lines @@
   SendWithTimeoutMixedOKAndTimeout(false);
   SendWithTimeoutMixedOKAndTimeout(true);
 }
 
 //------------------------------------------------------------------------------
 
 namespace {
 
 class NestedTask : public Task {
  public:
-  explicit NestedTask(Worker* server) : server_(server) { }
+  explicit NestedTask(Worker* server) : server_(server) {}
   void Run() {
     // Sleep a bit so that we wake up after the reply has been received.
     base::PlatformThread::Sleep(250);
     server_->SendAnswerToLife(true, base::kNoTimeout, true);
   }
 
   Worker* server_;
 };
 
 static bool timeout_occured = false;
@@ skipping 285 matching lines @@
   std::vector<Worker*> workers;
   workers.push_back(new NonRestrictedDispatchServer);
   workers.push_back(server);
   workers.push_back(
       new RestrictedDispatchClient(&sent_ping_event, server, &success));
   RunTest(workers);
   EXPECT_EQ(3, success);
 }
 
 }  // namespace IPC