Remove referrer from TransportSocketParams and SOCKSSocketParams.

net/socket/transport_client_socket_pool_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.
 
 #include "net/socket/transport_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 347 matching lines @@
   int delay_ms_;
 };
 
 class TransportClientSocketPoolTest : public testing::Test {
  protected:
   TransportClientSocketPoolTest()
       : connect_backup_jobs_enabled_(
           ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true)),
         params_(
             new TransportSocketParams(HostPortPair("www.google.com", 80),
-                                     kDefaultPriority, GURL(), false, false)),
+                                     kDefaultPriority, false, false)),
         low_params_(
             new TransportSocketParams(HostPortPair("www.google.com", 80),
-                                      LOW, GURL(), false, false)),
+                                      LOW, false, false)),
         histograms_(new ClientSocketPoolHistograms("TCPUnitTest")),
         host_resolver_(new MockHostResolver),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               histograms_.get(),
               host_resolver_.get(),
               &client_socket_factory_,
               NULL) {
   }
 
   ~TransportClientSocketPoolTest() {
     internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         connect_backup_jobs_enabled_);
   }
 
   int StartRequest(const std::string& group_name, RequestPriority priority) {
     scoped_refptr<TransportSocketParams> params(new TransportSocketParams(
-        HostPortPair("www.google.com", 80), MEDIUM, GURL(), false, false));
+        HostPortPair("www.google.com", 80), MEDIUM, false, false));
     return test_base_.StartRequestUsingPool(
         &pool_, group_name, priority, params);
   }
 
   int GetOrderOfRequest(size_t index) {
     return test_base_.GetOrderOfRequest(index);
   }
 
   bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
     return test_base_.ReleaseOneConnection(keep_alive);
@@ skipping 113 matching lines @@
 
   handle.Reset();
 }
 
 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) {
   host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
   TestOldCompletionCallback callback;
   ClientSocketHandle handle;
   HostPortPair host_port_pair("unresolvable.host.name", 80);
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
-          host_port_pair, kDefaultPriority, GURL(), false, false));
+          host_port_pair, kDefaultPriority, false, false));
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a", dest, kDefaultPriority, &callback, &pool_,
                         BoundNetLog()));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
 }
 
 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
   TestOldCompletionCallback callback;
@@ skipping 239 matching lines @@
       // run through the MessageLoop once to get it completely released.
       handle_->socket()->Disconnect();
       handle_->Reset();
       {
         MessageLoop::ScopedNestableTaskAllower nestable(
             MessageLoop::current());
         MessageLoop::current()->RunAllPending();
       }
       within_callback_ = true;
       scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
-          HostPortPair("www.google.com", 80), LOWEST, GURL(), false, false));
+          HostPortPair("www.google.com", 80), LOWEST, false, false));
       int rv = handle_->Init("a", dest, LOWEST, this, pool_, BoundNetLog());
       EXPECT_EQ(OK, rv);
     }
   }
 
   int WaitForResult() {
     return callback_.WaitForResult();
   }
 
  private:
   ClientSocketHandle* const handle_;
   TransportClientSocketPool* const pool_;
   bool within_callback_;
   TestOldCompletionCallback callback_;
 };
 
 TEST_F(TransportClientSocketPoolTest, RequestTwice) {
   ClientSocketHandle handle;
   RequestSocketCallback callback(&handle, &pool_);
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
-      HostPortPair("www.google.com", 80), LOWEST, GURL(), false, false));
+      HostPortPair("www.google.com", 80), LOWEST, false, false));
   int rv = handle.Init("a", dest, LOWEST, &callback, &pool_,
                        BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   // The callback is going to request "www.google.com". We want it to complete
   // synchronously this time.
   host_resolver_->set_synchronous_mode(true);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 412 matching lines @@
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv4AddressSize, endpoint.address().size());
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 }
 
 }  // namespace
 
 }  // namespace net