Random bits of header and whitespace cleanup.

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2010 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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 247 matching lines @@
  private:
   MessageLoop message_loop_;
 };
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 class SimpleServer : public Worker {
  public:
-  SimpleServer(bool pump_during_send)
+  explicit SimpleServer(bool pump_during_send)
       : Worker(Channel::MODE_SERVER, "simpler_server"),
         pump_during_send_(pump_during_send) { }
   void Run() {
     SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
     Done();
   }
 
   bool pump_during_send_;
 };
 
@@ skipping 140 matching lines @@
     if (delete_during_send_)
       ResetChannel();
   }
 
   bool pump_during_send_;
   bool delete_during_send_;
 };
 
 class UnblockClient : public Worker {
  public:
-  UnblockClient(bool pump_during_send)
+  explicit UnblockClient(bool pump_during_send)
     : Worker(Channel::MODE_CLIENT, "unblock_client"),
       pump_during_send_(pump_during_send) { }
 
   void OnAnswer(int* answer) {
     SendDouble(pump_during_send_, true);
     *answer = 42;
     Done();
   }
 
   bool pump_during_send_;
@@ skipping 130 matching lines @@
   RecursiveNoHang(true, true, false);
   RecursiveNoHang(true, true, true);
 }
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 class MultipleServer1 : public Worker {
  public:
-  MultipleServer1(bool pump_during_send)
+  explicit MultipleServer1(bool pump_during_send)
     : Worker("test_channel1", Channel::MODE_SERVER),
       pump_during_send_(pump_during_send) { }
 
   void Run() {
     SendDouble(pump_during_send_, true);
     Done();
   }
 
   bool pump_during_send_;
 };
@@ skipping 96 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 // This class provides server side functionality to test the case where
 // multiple sync channels are in use on the same thread on the client and
 // nested calls are issued.
 class QueuedReplyServer : public Worker {
  public:
-   QueuedReplyServer(base::Thread* listener_thread,
-                     const std::string& channel_name,
-                     const std::string& reply_text)
+  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) {
     LOG(INFO) << __FUNCTION__ << " Sending reply: "
               << reply_text_.c_str();
     SyncChannelNestedTestMsg_String::WriteReplyParams(
         reply_msg, reply_text_);
@@ skipping 91 matching lines @@
   QueuedReply(false);
   QueuedReply(true);
 }
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 class BadServer : public Worker {
  public:
-  BadServer(bool pump_during_send)
+  explicit BadServer(bool pump_during_send)
     : Worker(Channel::MODE_SERVER, "simpler_server"),
       pump_during_send_(pump_during_send) { }
   void Run() {
     int answer = 0;
 
     SyncMessage* msg = new SyncMessage(
         MSG_ROUTING_CONTROL, SyncChannelTestMsg_Double::ID,
         Message::PRIORITY_NORMAL, NULL);
     if (pump_during_send_)
       msg->EnableMessagePumping();
@@ skipping 70 matching lines @@
   ChattyServer(false);
   ChattyServer(true);
 }
 
 //------------------------------------------------------------------------------
 
 namespace {
 
 class TimeoutServer : public Worker {
  public:
-   TimeoutServer(int timeout_ms,
-                 std::vector<bool> timeout_seq,
-                 bool pump_during_send)
+  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) {
   }
 
   void Run() {
     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:
-   UnresponsiveClient(std::vector<bool> timeout_seq)
+  explicit UnresponsiveClient(std::vector<bool> timeout_seq)
       : Worker(Channel::MODE_CLIENT, "unresponsive_client"),
         timeout_seq_(timeout_seq) {
-   }
+  }
 
   void OnAnswerDelay(Message* reply_msg) {
     DCHECK(!timeout_seq_.empty());
     if (!timeout_seq_[0]) {
       SyncChannelTestMsg_AnswerToLife::WriteReplyParams(reply_msg, 42);
       Send(reply_msg);
     } else {
       // Don't reply.
       delete reply_msg;
     }
@@ skipping 62 matching lines @@
   SendWithTimeoutMixedOKAndTimeout(false);
   SendWithTimeoutMixedOKAndTimeout(true);
 }
 
 //------------------------------------------------------------------------------
 
 namespace {
 
 class NestedTask : public Task {
  public:
-  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.
     PlatformThread::Sleep(250);
     server_->SendAnswerToLife(true, base::kNoTimeout, true);
   }
 
   Worker* server_;
 };
 
 static bool timeout_occured = false;
@@ skipping 85 matching lines @@
 
 }  // namespace
 
 // Tests basic synchronous call
 TEST_F(IPCSyncChannelTest, SyncMessageFilter) {
   std::vector<Worker*> workers;
   workers.push_back(new SyncMessageFilterServer());
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }