Fix use-before-new issue in TestCastSocket.

extensions/browser/api/cast_channel/cast_socket_unittest.cc

 // Copyright 2014 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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
@@ skipping 167 matching lines @@
   }
 
   static std::unique_ptr<TestCastSocket> CreateSecure(
       Logger* logger,
       uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
     return std::unique_ptr<TestCastSocket>(new TestCastSocket(
         CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED,
         kDistantTimeoutMillis, logger, device_capabilities));
   }
 
   explicit TestCastSocket(const net::IPEndPoint& ip_endpoint,

[Wez, 2016/06/03 22:12:18]

nit: This doesn't need to be explicit, nor does the overload.

[krasin, 2016/06/03 22:20:58]

Done.

                           ChannelAuthType channel_auth,
                           int64_t timeout_ms,
                           Logger* logger,
                           uint64_t device_capabilities)
+      : TestCastSocket(ip_endpoint,
+                       channel_auth,
+                       timeout_ms,
+                       logger,
+                       new net::TestNetLog(),
+                       device_capabilities) {}
+
+  explicit TestCastSocket(const net::IPEndPoint& ip_endpoint,
+                          ChannelAuthType channel_auth,
+                          int64_t timeout_ms,
+                          Logger* logger,
+                          net::TestNetLog* capturing_net_log,
+                          uint64_t device_capabilities)
       : CastSocketImpl("some_extension_id",
                        ip_endpoint,
                        channel_auth,
-                       &capturing_net_log_,
+                       capturing_net_log,
                        base::TimeDelta::FromMilliseconds(timeout_ms),
                        false,
                        logger,
                        device_capabilities),
+        capturing_net_log_(capturing_net_log),
         ip_(ip_endpoint),
         extract_cert_result_(true),
         verify_challenge_result_(true),
         verify_challenge_disallow_(false),
         tcp_unresponsive_(false),
         mock_timer_(new base::MockTimer(false, false)),
         mock_transport_(nullptr) {}
 
   ~TestCastSocket() override {}
 
@@ skipping 78 matching lines @@
   std::unique_ptr<net::SSLClientSocket> CreateSslSocket(
       std::unique_ptr<net::StreamSocket> socket) override {
     net::MockConnect* connect_data = ssl_connect_data_.get();
     connect_data->peer_addr = ip_;
 
     ssl_data_.reset(new net::StaticSocketDataProvider(
         reads_.data(), reads_.size(), writes_.data(), writes_.size()));
     ssl_data_->set_connect_data(*connect_data);
     // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !!
     return std::unique_ptr<net::SSLClientSocket>(new net::MockTCPClientSocket(
-        net::AddressList(), &capturing_net_log_, ssl_data_.get()));
+        net::AddressList(), capturing_net_log_.get(), ssl_data_.get()));
   }
 
   scoped_refptr<net::X509Certificate> ExtractPeerCert() override {
     return extract_cert_result_ ? make_scoped_refptr<net::X509Certificate>(
                                       new net::X509Certificate(
                                           "", "", base::Time(), base::Time()))
                                 : nullptr;
   }
 
   bool VerifyChallengeReply() override {
     EXPECT_FALSE(verify_challenge_disallow_);
     return verify_challenge_result_;
   }
 
   base::Timer* GetTimer() override { return mock_timer_.get(); }
 
-  net::TestNetLog capturing_net_log_;
+  std::unique_ptr<net::TestNetLog> capturing_net_log_;
   net::IPEndPoint ip_;
   // Simulated connect data
   std::unique_ptr<net::MockConnect> tcp_connect_data_;
   std::unique_ptr<net::MockConnect> ssl_connect_data_;
   // Simulated read / write data
   std::vector<net::MockWrite> writes_;
   std::vector<net::MockRead> reads_;
   std::unique_ptr<net::SocketDataProvider> ssl_data_;
   // Simulated result of peer cert extraction.
   bool extract_cert_result_;
@@ skipping 559 matching lines @@
       logger_, cast_channel::CastDeviceCapability::VIDEO_OUT);
   EXPECT_FALSE(socket_->audio_only());
   EXPECT_TRUE(socket_->TestVerifyChannelPolicyNone());
   EXPECT_FALSE(socket_->audio_only());
   EXPECT_FALSE(socket_->TestVerifyChannelPolicyAudioOnly());
   EXPECT_TRUE(socket_->audio_only());
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions