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

ipc/ipc_fuzzing_tests.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 <stdio.h>
 #include <string>
 #include <sstream>
 
 #include "base/message_loop.h"
 #include "base/process_util.h"
@@ skipping 246 matching lines @@
   return 0;
 }
 
 class IPCFuzzingTest : public IPCChannelTest {
 };
 
 // This test makes sure that the FuzzerClientListener and FuzzerServerListener
 // are working properly by generating two well formed IPC calls.
 TEST_F(IPCFuzzingTest, SanityTest) {
   FuzzerClientListener listener;
-  IPC::Channel chan(kFuzzerChannel, IPC::Channel::MODE_SERVER,
-                    &listener);
+  IPC::Channel chan(kFuzzerChannel, IPC::Channel::MODE_SERVER, &listener);
   base::ProcessHandle server_process = SpawnChild(FUZZER_SERVER, &chan);
   ASSERT_TRUE(server_process);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
   ASSERT_TRUE(chan.Connect());
   listener.Init(&chan);
 
   IPC::Message* msg = NULL;
   int value = 43;
   msg = new MsgClassIS(value, L"expect 43");
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(value, MsgClassIS::ID));
 
   msg = new MsgClassSI(L"expect 44", ++value);
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(value, MsgClassSI::ID));
 
   EXPECT_TRUE(base::WaitForSingleProcess(
       server_process, base::TimeDelta::FromSeconds(5)));
   base::CloseProcessHandle(server_process);
 }
 
 // This test uses a payload that is smaller than expected.
 // This generates an error while unpacking the IPC buffer which in
 // In debug this triggers an assertion and in release it is ignored(!!). Right
 // after we generate another valid IPC to make sure framing is working
 // properly.
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 TEST_F(IPCFuzzingTest, MsgBadPayloadShort) {
   FuzzerClientListener listener;
-  IPC::Channel chan(kFuzzerChannel, IPC::Channel::MODE_SERVER,
-                    &listener);
+  IPC::Channel chan(kFuzzerChannel, IPC::Channel::MODE_SERVER, &listener);
   base::ProcessHandle server_process = SpawnChild(FUZZER_SERVER, &chan);
   ASSERT_TRUE(server_process);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
   ASSERT_TRUE(chan.Connect());
   listener.Init(&chan);
 
   IPC::Message* msg = new IPC::Message(MSG_ROUTING_CONTROL, MsgClassIS::ID,
                                        IPC::Message::PRIORITY_NORMAL);
   msg->WriteInt(666);
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMsgNotHandled(MsgClassIS::ID));
 
   msg = new MsgClassSI(L"expect one", 1);
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(1, MsgClassSI::ID));
 
   EXPECT_TRUE(base::WaitForSingleProcess(
       server_process, base::TimeDelta::FromSeconds(5)));
   base::CloseProcessHandle(server_process);
 }
 #endif
 
 // This test uses a payload that has too many arguments, but so the payload
 // size is big enough so the unpacking routine does not generate an error as
 // in the case of MsgBadPayloadShort test.
 // This test does not pinpoint a flaw (per se) as by design we don't carry
 // type information on the IPC message.
 TEST_F(IPCFuzzingTest, MsgBadPayloadArgs) {
   FuzzerClientListener listener;
-  IPC::Channel chan(kFuzzerChannel, IPC::Channel::MODE_SERVER,
-                    &listener);
+  IPC::Channel chan(kFuzzerChannel, IPC::Channel::MODE_SERVER, &listener);
   base::ProcessHandle server_process = SpawnChild(FUZZER_SERVER, &chan);
   ASSERT_TRUE(server_process);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
   ASSERT_TRUE(chan.Connect());
   listener.Init(&chan);
 
   IPC::Message* msg = new IPC::Message(MSG_ROUTING_CONTROL, MsgClassSI::ID,
                                        IPC::Message::PRIORITY_NORMAL);
   msg->WriteWString(L"d");
   msg->WriteInt(0);
@@ skipping 70 matching lines @@
   msg = new IPC::Message(MSG_ROUTING_CONTROL, MsgClassIS::ID,
                          IPC::Message::PRIORITY_NORMAL);
   msg->WriteInt(0x64);
   msg->WriteInt(0x32);
   EXPECT_FALSE(server.OnMessageReceived(*msg));
   delete msg;
 
   EXPECT_EQ(0, server.unhandled_msgs());
 #endif
 }