Convert implicit scoped_refptr constructor calls to explicit ones, part 1

remoting/protocol/jingle_chromotocol_connection_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.
 
 #include "base/time.h"
 #include "base/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 100 matching lines @@
     session_manager_pair_ = new SessionManagerPair(&thread_);
     session_manager_pair_->Init();
     host_server_ = new JingleChromotocolServer(&thread_);
     host_server_->set_allow_local_ips(true);
     host_server_->Init(SessionManagerPair::kHostJid,
                        session_manager_pair_->host_session_manager(),
                        NewCallback(&host_server_callback_,
                                    &MockServerCallback::OnIncomingConnection));
     client_server_ = new JingleChromotocolServer(&thread_);
     client_server_->set_allow_local_ips(true);
-    client_server_->Init(SessionManagerPair::kClientJid,
-                         session_manager_pair_->client_session_manager(),
-                         NewCallback(&client_server_callback_,
-                                     &MockServerCallback::OnIncomingConnection));
+    client_server_->Init(
+        SessionManagerPair::kClientJid,
+        session_manager_pair_->client_session_manager(),
+        NewCallback(&client_server_callback_,
+                    &MockServerCallback::OnIncomingConnection));
   }
 
   bool InitiateConnection() {
     EXPECT_CALL(host_server_callback_, OnIncomingConnection(_, _))
         .WillOnce(DoAll(
             WithArg<0>(Invoke(
                 this, &JingleChromotocolConnectionTest::SetHostConnection)),
             SetArgumentPointee<1>(ChromotocolServer::ACCEPT)));
 
     base::WaitableEvent host_connected_event(false, false);
@@ skipping 280 matching lines @@
  protected:
   virtual void InitBuffers() {
   }
 
   virtual void DoWrite() {
     if (packets_sent_ >= kMessages) {
       done_event_.Signal();
       return;
     }
 
-    scoped_refptr<net::IOBuffer> packet = new net::IOBuffer(kMessageSize);
+    scoped_refptr<net::IOBuffer> packet(new net::IOBuffer(kMessageSize));
     memset(packet->data(), 123, kMessageSize);
     sent_packets_[packets_sent_] = packet;
     // Put index of this packet in the beginning of the packet body.
     memcpy(packet->data(), &packets_sent_, sizeof(packets_sent_));
 
     int result = socket_1_->Write(packet, kMessageSize, &write_cb_);
     HandleWriteResult(result);
   }
 
   void OnWritten(int result) {
@@ skipping 108 matching lines @@
 // Verify that we can connect two endpoints.
 TEST_F(JingleChromotocolConnectionTest, Connect) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
 }
 
 // Verify that data can be transmitted over the event channel.
 TEST_F(JingleChromotocolConnectionTest, TestControlChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
-  scoped_refptr<TCPChannelTester> tester =
+  scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(thread_.message_loop(), host_connection_,
-                           client_connection_);
+                           client_connection_));
   tester->Start(ChannelTesterBase::CONTROL);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseConnections();
 }
 
 
 // Verify that data can be transmitted over the video channel.
 TEST_F(JingleChromotocolConnectionTest, TestVideoChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
-  scoped_refptr<TCPChannelTester> tester =
+  scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(thread_.message_loop(), host_connection_,
-                           client_connection_);
+                           client_connection_));
   tester->Start(ChannelTesterBase::VIDEO);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseConnections();
 }
 
 // Verify that data can be transmitted over the event channel.
 TEST_F(JingleChromotocolConnectionTest, TestEventChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
-  scoped_refptr<TCPChannelTester> tester =
+  scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(thread_.message_loop(), host_connection_,
-                           client_connection_);
+                           client_connection_));
   tester->Start(ChannelTesterBase::EVENT);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseConnections();
 }
 
 // Verify that data can be transmitted over the video RTP channel.
 TEST_F(JingleChromotocolConnectionTest, TestVideoRtpChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
-  scoped_refptr<UDPChannelTester> tester =
+  scoped_refptr<UDPChannelTester> tester(
       new UDPChannelTester(thread_.message_loop(), host_connection_,
-                           client_connection_);
+                           client_connection_));
   tester->Start(ChannelTesterBase::VIDEO_RTP);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseConnections();
 }
 
 }  // namespace remoting