FBTF: Even more ctor/virtual deinlining.

net/socket/socket_test_util.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 "net/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 
@@ skipping 523 matching lines @@
   if (is_npn_state_set_)
     return new_npn_value_;
   return data_->was_npn_negotiated;
 }
 
 bool MockSSLClientSocket::set_was_npn_negotiated(bool negotiated) {
   is_npn_state_set_ = true;
   return new_npn_value_ = negotiated;
 }
 
+StaticSocketDataProvider::StaticSocketDataProvider()
+    : reads_(NULL),
+      read_index_(0),
+      read_count_(0),
+      writes_(NULL),
+      write_index_(0),
+      write_count_(0) {
+}
+
+StaticSocketDataProvider::StaticSocketDataProvider(MockRead* reads,
+                                                   size_t reads_count,
+                                                   MockWrite* writes,
+                                                   size_t writes_count)
+    : reads_(reads),
+      read_index_(0),
+      read_count_(reads_count),
+      writes_(writes),
+      write_index_(0),
+      write_count_(writes_count) {
+}
+
+StaticSocketDataProvider::~StaticSocketDataProvider() {}
+
 MockRead StaticSocketDataProvider::GetNextRead() {
   DCHECK(!at_read_eof());
   reads_[read_index_].time_stamp = base::Time::Now();
   return reads_[read_index_++];
 }
 
 MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
   if (!writes_) {
     // Not using mock writes; succeed synchronously.
     return MockWriteResult(false, data.length());
@@ skipping 48 matching lines @@
 void StaticSocketDataProvider::Reset() {
   read_index_ = 0;
   write_index_ = 0;
 }
 
 DynamicSocketDataProvider::DynamicSocketDataProvider()
     : short_read_limit_(0),
       allow_unconsumed_reads_(false) {
 }
 
+DynamicSocketDataProvider::~DynamicSocketDataProvider() {}
+
 MockRead DynamicSocketDataProvider::GetNextRead() {
   if (reads_.empty())
     return MockRead(false, ERR_UNEXPECTED);
   MockRead result = reads_.front();
   if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) {
     reads_.pop_front();
   } else {
     result.data_len = short_read_limit_;
     reads_.front().data += result.data_len;
     reads_.front().data_len -= result.data_len;
@@ skipping 155 matching lines @@
     callback_->RunWithParams(Tuple1<int>(ERR_IO_PENDING));
 }
 
 void OrderedSocketData::CompleteRead() {
   if (socket()) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_;
     socket()->OnReadComplete(GetNextRead());
   }
 }
 
+OrderedSocketData::~OrderedSocketData() {}
+
 DeterministicSocketData::DeterministicSocketData(MockRead* reads,
     size_t reads_count, MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       sequence_number_(0),
       current_read_(),
       current_write_(),
       stopping_sequence_number_(0),
       stopped_(false),
       print_debug_(false) {}
 
@@ skipping 130 matching lines @@
 
 void DeterministicSocketData::NextStep() {
   // Invariant: Can never move *past* the stopping step.
   DCHECK_LT(sequence_number_, stopping_sequence_number_);
   sequence_number_++;
   if (sequence_number_ == stopping_sequence_number_)
     SetStopped(true);
 }
 
 
+MockClientSocketFactory::MockClientSocketFactory() {}
+
+MockClientSocketFactory::~MockClientSocketFactory() {}
+
 void MockClientSocketFactory::AddSocketDataProvider(
     SocketDataProvider* data) {
   mock_data_.Add(data);
 }
 
 void MockClientSocketFactory::AddSSLSocketDataProvider(
     SSLSocketDataProvider* data) {
   mock_ssl_data_.Add(data);
 }
 
@@ skipping 30 matching lines @@
     ClientSocketHandle* transport_socket,
     const std::string& hostname,
     const SSLConfig& ssl_config) {
   MockSSLClientSocket* socket =
       new MockSSLClientSocket(transport_socket, hostname, ssl_config,
                               mock_ssl_data_.GetNext());
   ssl_client_sockets_.push_back(socket);
   return socket;
 }
 
+DeterministicMockClientSocketFactory::DeterministicMockClientSocketFactory() {}
+
+DeterministicMockClientSocketFactory::~DeterministicMockClientSocketFactory() {}
+
 void DeterministicMockClientSocketFactory::AddSocketDataProvider(
     DeterministicSocketData* data) {
   mock_data_.Add(data);
 }
 
 void DeterministicMockClientSocketFactory::AddSSLSocketDataProvider(
     SSLSocketDataProvider* data) {
   mock_ssl_data_.Add(data);
 }
 
@@ skipping 99 matching lines @@
     ClientSocket* socket,
     ClientSocketHandle* handle,
     CompletionCallback* callback)
     : socket_(socket),
       handle_(handle),
       user_callback_(callback),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           connect_callback_(this, &MockConnectJob::OnConnect)) {
 }
 
+MockTCPClientSocketPool::MockConnectJob::~MockConnectJob() {}
+
 int MockTCPClientSocketPool::MockConnectJob::Connect() {
   int rv = socket_->Connect(&connect_callback_);
   if (rv == OK) {
     user_callback_ = NULL;
     OnConnect(OK);
   }
   return rv;
 }
 
 bool MockTCPClientSocketPool::MockConnectJob::CancelHandle(
@@ skipping 111 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net