Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/sequenced_socket_data_unittest.cc

 // Copyright 2015 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 <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 217 matching lines @@
 SequencedSocketDataTest::SequencedSocketDataTest()
     : failing_callback_(
           base::Bind(&SequencedSocketDataTest::FailingCompletionCallback,
                      base::Unretained(this))),
       sock_(nullptr),
       connect_data_(SYNCHRONOUS, OK),
       endpoint_("www.google.com", 443),
       tcp_params_(new TransportSocketParams(
           endpoint_,
           false,
-          false,
           OnHostResolutionCallback(),
           TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
       socket_pool_(10, 10, &socket_factory_),
       expect_eof_(true) {
 }
 
 SequencedSocketDataTest::~SequencedSocketDataTest() {
   // Make sure no unexpected pending tasks will cause a failure.
   base::RunLoop().RunUntilIdle();
   if (expect_eof_) {
     EXPECT_EQ(expect_eof_, data_->AllReadDataConsumed());
     EXPECT_EQ(expect_eof_, data_->AllWriteDataConsumed());
   }
 }
 
 void SequencedSocketDataTest::Initialize(MockRead* reads,
                                          size_t reads_count,
                                          MockWrite* writes,
                                          size_t writes_count) {
   data_.reset(
       new SequencedSocketData(reads, reads_count, writes, writes_count));
   data_->set_connect_data(connect_data_);
   socket_factory_.AddSocketDataProvider(data_.get());
 
   EXPECT_EQ(OK,
             connection_.Init(
-                endpoint_.ToString(), tcp_params_, LOWEST, CompletionCallback(),
+                endpoint_.ToString(), tcp_params_, LOWEST,
+                ClientSocketPool::IgnoreLimits::DISABLED, CompletionCallback(),
                 reinterpret_cast<TransportClientSocketPool*>(&socket_pool_),
                 BoundNetLog()));
   sock_ = connection_.socket();
 }
 
 void SequencedSocketDataTest::AssertSyncReadEquals(const char* data, int len) {
   // Issue the read, which will complete immediately.
   AssertReadReturns(len, len);
   AssertReadBufferEquals(data, len);
 }
@@ skipping 965 matching lines @@
 
   Resume();
   ASSERT_FALSE(IsPaused());
   ASSERT_TRUE(write_callback_.have_result());
   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
 }
 
 }  // namespace
 
 }  // namespace net