More net/ reordering.

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 164 matching lines @@
   const MockRead& PeekRead(size_t index) const;
   const MockWrite& PeekWrite(size_t index) const;
   size_t read_index() const { return read_index_; }
   size_t write_index() const { return write_index_; }
   size_t read_count() const { return read_count_; }
   size_t write_count() const { return write_count_; }
 
   bool at_read_eof() const { return read_index_ >= read_count_; }
   bool at_write_eof() const { return write_index_ >= write_count_; }
 
+  virtual void CompleteRead() {}
+
   // SocketDataProvider methods:
   virtual MockRead GetNextRead();
   virtual MockWriteResult OnWrite(const std::string& data);
   virtual void Reset();
-  virtual void CompleteRead() {}
 
  private:
   MockRead* reads_;
   size_t read_index_;
   size_t read_count_;
   MockWrite* writes_;
   size_t write_index_;
   size_t write_count_;
 
   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();
 
+  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; }
+
   // 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; }
-
  protected:
   // The next time there is a read from this socket, it will return |data|.
   // Before calling SimulateRead next time, the previous data must be consumed.
   void SimulateRead(const char* data, size_t length);
   void SimulateRead(const char* data) {
     SimulateRead(data, std::strlen(data));
   }
 
  private:
   std::deque<MockRead> reads_;
@@ skipping 46 matching lines @@
   //               a MockRead to complete.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
   // Note: The MockRead and MockWrite lists musts end with a EOF
   //       e.g. a MockRead(true, 0, 0);
   DelayedSocketData(const MockConnect& connect, int write_delay,
                     MockRead* reads, size_t reads_count,
                     MockWrite* writes, size_t writes_count);
   ~DelayedSocketData();
 
+  void ForceNextRead();
+
+  // StaticSocketDataProvider:
   virtual MockRead GetNextRead();
   virtual MockWriteResult OnWrite(const std::string& data);
   virtual void Reset();
   virtual void CompleteRead();
-  void ForceNextRead();
 
  private:
   int write_delay_;
   ScopedRunnableMethodFactory<DelayedSocketData> factory_;
 };
 
 // A DataProvider where the reads are ordered.
 // If a read is requested before its sequence number is reached, we return an
 // ERR_IO_PENDING (that way we don't have to explicitly add a MockRead just to
 // wait).
@@ skipping 18 matching lines @@
   // |connect| the result for the connect phase.
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
   // Note: The MockRead and MockWrite lists musts end with a EOF
   //       e.g. a MockRead(true, 0, 0);
   OrderedSocketData(const MockConnect& connect,
                     MockRead* reads, size_t reads_count,
                     MockWrite* writes, size_t writes_count);
 
-  virtual MockRead GetNextRead();
-  virtual MockWriteResult OnWrite(const std::string& data);
-  virtual void Reset();
-  virtual void CompleteRead();
-
   void SetCompletionCallback(CompletionCallback* callback) {
     callback_ = callback;
   }
 
   // Posts a quit message to the current message loop, if one is running.
   void EndLoop();
 
+  // StaticSocketDataProvider:
+  virtual MockRead GetNextRead();
+  virtual MockWriteResult OnWrite(const std::string& data);
+  virtual void Reset();
+  virtual void CompleteRead();
+
  private:
   friend class base::RefCounted<OrderedSocketData>;
   virtual ~OrderedSocketData();
 
   int sequence_number_;
   int loop_stop_stage_;
   CompletionCallback* callback_;
   bool blocked_;
   ScopedRunnableMethodFactory<OrderedSocketData> factory_;
 };
@@ skipping 57 matching lines @@
 //
 // For examples of how to use this class, see:
 //   deterministic_socket_data_unittests.cc
 class DeterministicSocketData : public StaticSocketDataProvider,
     public base::RefCounted<DeterministicSocketData> {
  public:
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   DeterministicSocketData(MockRead* reads, size_t reads_count,
                           MockWrite* writes, size_t writes_count);
-
-  // When the socket calls Read(), that calls GetNextRead(), and expects either
-  // ERR_IO_PENDING or data.
-  virtual MockRead GetNextRead();
-
-  // When the socket calls Write(), it always completes synchronously. OnWrite()
-  // checks to make sure the written data matches the expected data. The
-  // callback will not be invoked until its sequence number is reached.
-  virtual MockWriteResult OnWrite(const std::string& data);
-
-  virtual void Reset();
-
-  virtual void CompleteRead() {}
+  virtual ~DeterministicSocketData();
 
   // Consume all the data up to the give stop point (via SetStop()).
   void Run();
 
   // Set the stop point to be |steps| from now, and then invoke Run().
   void RunFor(int steps);
 
   // Stop at step |seq|, which must be in the future.
-  virtual void SetStop(int seq) {
-    DCHECK_LT(sequence_number_, seq);
-    stopping_sequence_number_ = seq;
-    stopped_ = false;
-  }
+  virtual void SetStop(int seq);
 
   // Stop |seq| steps after the current step.
-  virtual void StopAfter(int seq) {
-    SetStop(sequence_number_ + seq);
-  }
+  virtual void StopAfter(int seq);
   bool stopped() const { return stopped_; }
   void SetStopped(bool val) { stopped_ = val; }
   MockRead& current_read() { return current_read_; }
   MockRead& current_write() { return current_write_; }
   int sequence_number() const { return sequence_number_; }
   void set_socket(base::WeakPtr<DeterministicMockTCPClientSocket> socket) {
     socket_ = socket;
   }
 
+  // StaticSocketDataProvider:
+
+  // When the socket calls Read(), that calls GetNextRead(), and expects either
+  // ERR_IO_PENDING or data.
+  virtual MockRead GetNextRead();
+
+  // When the socket calls Write(), it always completes synchronously. OnWrite()
+  // checks to make sure the written data matches the expected data. The
+  // callback will not be invoked until its sequence number is reached.
+  virtual MockWriteResult OnWrite(const std::string& data);
+  virtual void Reset();
+  virtual void CompleteRead() {}
+
  private:
   // Invoke the read and write callbacks, if the timing is appropriate.
   void InvokeCallbacks();
 
   void NextStep();
 
   int sequence_number_;
   MockRead current_read_;
   MockWrite current_write_;
   int stopping_sequence_number_;
   bool stopped_;
   base::WeakPtr<DeterministicMockTCPClientSocket> socket_;
   bool print_debug_;
 };
 
-
 // Holds an array of SocketDataProvider elements.  As Mock{TCP,SSL}ClientSocket
 // objects get instantiated, they take their data from the i'th element of this
 // array.
 template<typename T>
 class SocketDataProviderArray {
  public:
   SocketDataProviderArray() : next_index_(0) {
   }
 
   T* GetNext() {
@@ skipping 37 matching lines @@
   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.
   MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
 
+  SocketDataProviderArray<SocketDataProvider>& mock_data() {
+    return mock_data_;
+  }
+  std::vector<MockTCPClientSocket*>& tcp_client_sockets() {
+    return tcp_client_sockets_;
+  }
+
   // ClientSocketFactory
   virtual ClientSocket* CreateTCPClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source);
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       CertVerifier* cert_verifier,
       DnsCertProvenanceChecker* dns_cert_checker);
-  SocketDataProviderArray<SocketDataProvider>& mock_data() {
-    return mock_data_;
-  }
-  std::vector<MockTCPClientSocket*>& tcp_client_sockets() {
-    return tcp_client_sockets_;
-  }
 
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
 
   // Store pointers to handed out sockets in case the test wants to get them.
   std::vector<MockTCPClientSocket*> tcp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockClientSocket : public net::SSLClientSocket {
  public:
   explicit MockClientSocket(net::NetLog* net_log);
+
+  // If an async IO is pending because the SocketDataProvider returned
+  // ERR_IO_PENDING, then the MockClientSocket waits until this OnReadComplete
+  // is called to complete the asynchronous read operation.
+  // data.async is ignored, and this read is completed synchronously as
+  // part of this call.
+  virtual void OnReadComplete(const MockRead& data) = 0;
+
+  // Socket methods:
+  virtual int Read(net::IOBuffer* buf, int buf_len,
+                   net::CompletionCallback* callback) = 0;
+  virtual int Write(net::IOBuffer* buf, int buf_len,
+                    net::CompletionCallback* callback) = 0;
+  virtual bool SetReceiveBufferSize(int32 size);
+  virtual bool SetSendBufferSize(int32 size);
+
   // ClientSocket methods:
   virtual int Connect(net::CompletionCallback* callback) = 0;
   virtual void Disconnect();
   virtual bool IsConnected() const;
   virtual bool IsConnectedAndIdle() const;
   virtual int GetPeerAddress(AddressList* address) const;
-  virtual const BoundNetLog& NetLog() const { return net_log_;}
+  virtual const BoundNetLog& NetLog() const;
   virtual void SetSubresourceSpeculation() {}
   virtual void SetOmniboxSpeculation() {}
 
   // SSLClientSocket methods:
   virtual void GetSSLInfo(net::SSLInfo* ssl_info);
   virtual void GetSSLCertRequestInfo(
       net::SSLCertRequestInfo* cert_request_info);
   virtual NextProtoStatus GetNextProto(std::string* proto);
 
-  // Socket methods:
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::CompletionCallback* callback) = 0;
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::CompletionCallback* callback) = 0;
-  virtual bool SetReceiveBufferSize(int32 size) { return true; }
-  virtual bool SetSendBufferSize(int32 size) { return true; }
-
-  // If an async IO is pending because the SocketDataProvider returned
-  // ERR_IO_PENDING, then the MockClientSocket waits until this OnReadComplete
-  // is called to complete the asynchronous read operation.
-  // data.async is ignored, and this read is completed synchronously as
-  // part of this call.
-  virtual void OnReadComplete(const MockRead& data) = 0;
-
  protected:
-  virtual ~MockClientSocket() {}
+  virtual ~MockClientSocket();
   void RunCallbackAsync(net::CompletionCallback* callback, int result);
   void RunCallback(net::CompletionCallback*, int result);
 
   ScopedRunnableMethodFactory<MockClientSocket> method_factory_;
 
   // True if Connect completed successfully and Disconnect hasn't been called.
   bool connected_;
 
   net::BoundNetLog net_log_;
 };
 
 class MockTCPClientSocket : public MockClientSocket {
  public:
   MockTCPClientSocket(const net::AddressList& addresses, net::NetLog* net_log,
                       net::SocketDataProvider* socket);
 
-  // ClientSocket methods:
-  virtual int Connect(net::CompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const { return IsConnected(); }
-  virtual bool WasEverUsed() const { return was_used_to_convey_data_; }
-  virtual bool UsingTCPFastOpen() const { return false; }
+  net::AddressList addresses() const { return addresses_; }
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    net::CompletionCallback* callback);
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::CompletionCallback* callback);
 
+  // ClientSocket methods:
+  virtual int Connect(net::CompletionCallback* callback);
+  virtual void Disconnect();
+  virtual bool IsConnected() const;
+  virtual bool IsConnectedAndIdle() const;
+  virtual bool WasEverUsed() const;
+  virtual bool UsingTCPFastOpen() const;
+
+  // MockClientSocket:
   virtual void OnReadComplete(const MockRead& data);
 
-  net::AddressList addresses() const { return addresses_; }
-
  private:
   int CompleteRead();
 
   net::AddressList addresses_;
 
   net::SocketDataProvider* data_;
   int read_offset_;
   net::MockRead read_data_;
   bool need_read_data_;
 
   // True if the peer has closed the connection.  This allows us to simulate
   // the recv(..., MSG_PEEK) call in the IsConnectedAndIdle method of the real
   // TCPClientSocket.
   bool peer_closed_connection_;
 
   // While an asynchronous IO is pending, we save our user-buffer state.
   net::IOBuffer* pending_buf_;
   int pending_buf_len_;
   net::CompletionCallback* pending_callback_;
   bool was_used_to_convey_data_;
 };
 
 class DeterministicMockTCPClientSocket : public MockClientSocket,
     public base::SupportsWeakPtr<DeterministicMockTCPClientSocket> {
  public:
   DeterministicMockTCPClientSocket(net::NetLog* net_log,
       net::DeterministicSocketData* data);
-
-  // ClientSocket methods:
-  virtual int Connect(net::CompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const { return IsConnected(); }
-  virtual bool WasEverUsed() const { return was_used_to_convey_data_; }
-  virtual bool UsingTCPFastOpen() const { return false; }
-
-  // Socket methods:
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::CompletionCallback* callback);
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::CompletionCallback* callback);
+  virtual ~DeterministicMockTCPClientSocket();
 
   bool write_pending() const { return write_pending_; }
   bool read_pending() const { return read_pending_; }
 
   void CompleteWrite();
   int CompleteRead();
-  void OnReadComplete(const MockRead& data);
+
+  // Socket:
+  virtual int Write(net::IOBuffer* buf, int buf_len,
+                    net::CompletionCallback* callback);
+  virtual int Read(net::IOBuffer* buf, int buf_len,
+                   net::CompletionCallback* callback);
+
+  // ClientSocket:
+  virtual int Connect(net::CompletionCallback* callback);
+  virtual void Disconnect();
+  virtual bool IsConnected() const;
+  virtual bool IsConnectedAndIdle() const;
+  virtual bool WasEverUsed() const;
+  virtual bool UsingTCPFastOpen() const;
+
+  // MockClientSocket:
+  virtual void OnReadComplete(const MockRead& data);
 
  private:
   bool write_pending_;
   net::CompletionCallback* write_callback_;
   int write_result_;
 
   net::MockRead read_data_;
 
   net::IOBuffer* read_buf_;
   int read_buf_len_;
   bool read_pending_;
   net::CompletionCallback* read_callback_;
   net::DeterministicSocketData* data_;
   bool was_used_to_convey_data_;
 };
 
 class MockSSLClientSocket : public MockClientSocket {
  public:
   MockSSLClientSocket(
       net::ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const net::SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       net::SSLSocketDataProvider* socket);
-  ~MockSSLClientSocket();
+  virtual ~MockSSLClientSocket();
+
+  // Socket methods:
+  virtual int Read(net::IOBuffer* buf, int buf_len,
+                   net::CompletionCallback* callback);
+  virtual int Write(net::IOBuffer* buf, int buf_len,
+                    net::CompletionCallback* callback);
 
   // ClientSocket methods:
   virtual int Connect(net::CompletionCallback* callback);
   virtual void Disconnect();
   virtual bool IsConnected() const;
   virtual bool WasEverUsed() const;
   virtual bool UsingTCPFastOpen() const;
 
-  // Socket methods:
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::CompletionCallback* callback);
-  virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::CompletionCallback* callback);
-
   // SSLClientSocket methods:
   virtual void GetSSLInfo(net::SSLInfo* ssl_info);
   virtual void GetSSLCertRequestInfo(
       net::SSLCertRequestInfo* cert_request_info);
   virtual NextProtoStatus GetNextProto(std::string* proto);
   virtual bool was_npn_negotiated() const;
   virtual bool set_was_npn_negotiated(bool negotiated);
 
   // This MockSocket does not implement the manual async IO feature.
-  virtual void OnReadComplete(const MockRead& data) { NOTIMPLEMENTED(); }
+  virtual void OnReadComplete(const MockRead& data);
 
  private:
   class ConnectCallback;
 
   scoped_ptr<ClientSocketHandle> transport_;
   net::SSLSocketDataProvider* data_;
   bool is_npn_state_set_;
   bool new_npn_value_;
   bool was_used_to_convey_data_;
 };
@@ skipping 134 matching lines @@
   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;
 
+  SocketDataProviderArray<DeterministicSocketData>& mock_data() {
+    return mock_data_;
+  }
+  std::vector<DeterministicMockTCPClientSocket*>& tcp_client_sockets() {
+    return tcp_client_sockets_;
+  }
+
   // ClientSocketFactory
   virtual ClientSocket* CreateTCPClientSocket(const AddressList& addresses,
                                               NetLog* net_log,
                                               const NetLog::Source& source);
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       CertVerifier* cert_verifier,
       DnsCertProvenanceChecker* dns_cert_checker);
 
-  SocketDataProviderArray<DeterministicSocketData>& mock_data() {
-    return mock_data_;
-  }
-  std::vector<DeterministicMockTCPClientSocket*>& tcp_client_sockets() {
-    return tcp_client_sockets_;
-  }
-
  private:
   SocketDataProviderArray<DeterministicSocketData> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
 
   // Store pointers to handed out sockets in case the test wants to get them.
   std::vector<DeterministicMockTCPClientSocket*> tcp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockSOCKSClientSocketPool : public SOCKSClientSocketPool {
@@ skipping 34 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_