Add Socket::ReadIfReady()

net/socket/socket_test_util.h

 // Copyright (c) 2012 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_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 500 matching lines @@
   ~MockClientSocketFactory() override;
 
   void AddSocketDataProvider(SocketDataProvider* socket);
   void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
   SocketDataProviderArray<SocketDataProvider>& mock_data() {
     return mock_data_;
   }
 
+  // If |enable_read_if_ready|, ReadIfReady() will be implemented.
+  void set_enable_read_if_ready(bool enable_read_if_ready) {
+    enable_read_if_ready_ = enable_read_if_ready;
+  }
+
   // ClientSocketFactory
   std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
       const NetLogSource& source) override;
   std::unique_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
       NetLog* net_log,
       const NetLogSource& source) override;
   std::unique_ptr<SSLClientSocket> CreateSSLClientSocket(
       std::unique_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       const SSLClientSocketContext& context) override;
   void ClearSSLSessionCache() override;
 
   const std::vector<uint16_t>& udp_client_socket_ports() const {
     return udp_client_socket_ports_;
   }
 
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
   std::vector<uint16_t> udp_client_socket_ports_;
 
+  bool enable_read_if_ready_;
   DISALLOW_COPY_AND_ASSIGN(MockClientSocketFactory);
 };
 
 class MockClientSocket : public SSLClientSocket {
  public:
   // The NetLogWithSource is needed to test LoadTimingInfo, which uses NetLog
   // IDs as
   // unique socket IDs.
   explicit MockClientSocket(const NetLogWithSource& net_log);
 
@@ skipping 62 matching lines @@
                       net::NetLog* net_log,
                       SocketDataProvider* socket);
   ~MockTCPClientSocket() override;
 
   const AddressList& addresses() const { return addresses_; }
 
   // Socket implementation.
   int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override;
+  int ReadIfReady(IOBuffer* buf,
+                  int buf_len,
+                  const CompletionCallback& callback) override;
   int Write(IOBuffer* buf,
             int buf_len,
             const CompletionCallback& callback) override;
 
   // StreamSocket implementation.
   int Connect(const CompletionCallback& callback) override;
   void Disconnect() override;
   bool IsConnected() const override;
   bool IsConnectedAndIdle() const override;
   int GetPeerAddress(IPEndPoint* address) const override;
   bool WasEverUsed() const override;
   void EnableTCPFastOpenIfSupported() override;
   bool GetSSLInfo(SSLInfo* ssl_info) override;
   void GetConnectionAttempts(ConnectionAttempts* out) const override;
   void ClearConnectionAttempts() override;
   void AddConnectionAttempts(const ConnectionAttempts& attempts) override;
 
   // AsyncSocket:
   void OnReadComplete(const MockRead& data) override;
   void OnWriteComplete(int rv) override;
   void OnConnectComplete(const MockConnect& data) override;
   void OnDataProviderDestroyed() override;
 
+  // If |enable_read_if_ready|, ReadIfReady() will be implemented.
+  void set_enable_read_if_ready(bool enable_read_if_ready) {
+    enable_read_if_ready_ = enable_read_if_ready;
+  }
+
  private:
-  int CompleteRead();
-
+  void RetryRead(int rv);
+  int ReadIfReadyHelper(IOBuffer* buf,
+                        int buf_len,
+                        const CompletionCallback& callback);
   AddressList addresses_;
 
   SocketDataProvider* data_;
   int read_offset_;
   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 read is pending, we save our user-buffer state.
   scoped_refptr<IOBuffer> pending_read_buf_;
   int pending_read_buf_len_;
+  CompletionCallback pending_read_callback_;
+
+  // Non-null when a ReadIfReady() is pending.
+  CompletionCallback pending_read_if_ready_callback_;
+
   CompletionCallback pending_connect_callback_;
-  CompletionCallback pending_read_callback_;
   CompletionCallback pending_write_callback_;
   bool was_used_to_convey_data_;
+  bool enable_read_if_ready_;
 
   ConnectionAttempts connection_attempts_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTCPClientSocket);
 };
 
 class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockSSLClientSocket(std::unique_ptr<ClientSocketHandle> transport_socket,
                       const HostPortPair& host_and_port,
                       const SSLConfig& ssl_config,
                       SSLSocketDataProvider* socket);
   ~MockSSLClientSocket() override;
 
   // Socket implementation.
   int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override;
+  int ReadIfReady(IOBuffer* buf,
+                  int buf_len,
+                  const CompletionCallback& callback) override;
   int Write(IOBuffer* buf,
             int buf_len,
             const CompletionCallback& callback) override;
 
   // StreamSocket implementation.
   int Connect(const CompletionCallback& callback) override;
   void Disconnect() override;
   bool IsConnected() const override;
   bool IsConnectedAndIdle() const override;
   bool WasEverUsed() const override;
@@ skipping 312 matching lines @@
 
 // Helper function to get the total data size of the MockReads in |reads|.
 int64_t CountReadBytes(const MockRead reads[], size_t reads_size);
 
 // Helper function to get the total data size of the MockWrites in |writes|.
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size);
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_