FBTF: Even more ctor/virtual deinlining.

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 #pragma once
 
 #include <cstring>
 #include <deque>
@@ skipping 144 matching lines @@
   MockConnect connect_;
   MockClientSocket* socket_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketDataProvider);
 };
 
 // SocketDataProvider which responds based on static tables of mock reads and
 // writes.
 class StaticSocketDataProvider : public SocketDataProvider {
  public:
-  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) {
-  }
-  virtual ~StaticSocketDataProvider() {}
+                           MockWrite* writes, size_t writes_count);
+  virtual ~StaticSocketDataProvider();
 
   // SocketDataProvider methods:
   virtual MockRead GetNextRead();
   virtual MockWriteResult OnWrite(const std::string& data);
   virtual void Reset();
 
   // These functions get access to the next available read and write data.
   const MockRead& PeekRead() const;
   const MockWrite& PeekWrite() const;
   // These functions get random access to the read and write data, for timing.
@@ skipping 18 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StaticSocketDataProvider);
 };
 
 // SocketDataProvider which can make decisions about next mock reads based on
 // received writes. It can also be used to enforce order of operations, for
 // example that tested code must send the "Hello!" message before receiving
 // response. This is useful for testing conversation-like protocols like FTP.
 class DynamicSocketDataProvider : public SocketDataProvider {
  public:
   DynamicSocketDataProvider();
+  virtual ~DynamicSocketDataProvider();
 
   // SocketDataProvider methods:
   virtual MockRead GetNextRead();
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
   virtual void Reset();
 
   int short_read_limit() const { return short_read_limit_; }
   void set_short_read_limit(int limit) { short_read_limit_ = limit; }
 
   void allow_unconsumed_reads(bool allow) { allow_unconsumed_reads_ = allow; }
@@ skipping 111 matching lines @@
   void SetCompletionCallback(CompletionCallback* callback) {
     callback_ = callback;
   }
 
   // Posts a quit message to the current message loop, if one is running.
   void EndLoop();
 
   void CompleteRead();
 
  private:
+  friend class base::RefCounted<OrderedSocketData>;
+  virtual ~OrderedSocketData();
+
   int sequence_number_;
   int loop_stop_stage_;
   CompletionCallback* callback_;
   bool blocked_;
   ScopedRunnableMethodFactory<OrderedSocketData> factory_;
 };
 
 class DeterministicMockTCPClientSocket;
 
 // This class gives the user full control over the network activity,
@@ skipping 150 matching lines @@
 class MockTCPClientSocket;
 class MockSSLClientSocket;
 
 // ClientSocketFactory which contains arrays of sockets of each type.
 // You should first fill the arrays using AddMock{SSL,}Socket. When the factory
 // is asked to create a socket, it takes next entry from appropriate array.
 // You can use ResetNextMockIndexes to reset that next entry index for all mock
 // socket types.
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
+  MockClientSocketFactory();
+  virtual ~MockClientSocketFactory();
+
   void AddSocketDataProvider(SocketDataProvider* socket);
   void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
   // Return |index|-th MockTCPClientSocket (starting from 0) that the factory
   // created.
   MockTCPClientSocket* GetMockTCPClientSocket(size_t index) const;
 
   // Return |index|-th MockSSLClientSocket (starting from 0) that the factory
   // created.
@@ skipping 270 matching lines @@
   std::vector<TestSocketRequest*> request_order_;
   size_t completion_count_;
 };
 
 class MockTCPClientSocketPool : public TCPClientSocketPool {
  public:
   class MockConnectJob {
    public:
     MockConnectJob(ClientSocket* socket, ClientSocketHandle* handle,
                    CompletionCallback* callback);
+    ~MockConnectJob();
 
     int Connect();
     bool CancelHandle(const ClientSocketHandle* handle);
 
    private:
     void OnConnect(int rv);
 
     scoped_ptr<ClientSocket> socket_;
     ClientSocketHandle* handle_;
     CompletionCallback* user_callback_;
@@ skipping 30 matching lines @@
   ClientSocketFactory* client_socket_factory_;
   ScopedVector<MockConnectJob> job_list_;
   int release_count_;
   int cancel_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTCPClientSocketPool);
 };
 
 class DeterministicMockClientSocketFactory : public ClientSocketFactory {
  public:
+  DeterministicMockClientSocketFactory();
+  virtual ~DeterministicMockClientSocketFactory();
+
   void AddSocketDataProvider(DeterministicSocketData* socket);
   void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
   // Return |index|-th MockSSLClientSocket (starting from 0) that the factory
   // created.
   MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
 
   // ClientSocketFactory
   virtual ClientSocket* CreateTCPClientSocket(const AddressList& addresses,
@@ skipping 58 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_