Fix HttpStreamParser::CanReuseConnection().

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 <stdint.h>
 
 #include <cstring>
@@ skipping 172 matching lines @@
   MockWriteResult(IoMode io_mode, int result) : mode(io_mode), result(result) {}
 
   IoMode mode;
   int result;
 };
 
 // The SocketDataProvider is an interface used by the MockClientSocket
 // for getting data about individual reads and writes on the socket.
 class SocketDataProvider {
  public:
-  SocketDataProvider() : socket_(NULL) {}
-
-  virtual ~SocketDataProvider() {}
+  SocketDataProvider();
+  virtual ~SocketDataProvider();
 
   // Returns the buffer and result code for the next simulated read.
   // If the |MockRead.result| is ERR_IO_PENDING, it informs the caller
   // that it will be called via the AsyncSocket::OnReadComplete()
   // function at a later time.
   virtual MockRead OnRead() = 0;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
   virtual void Reset() = 0;
   virtual bool AllReadDataConsumed() const = 0;
   virtual bool AllWriteDataConsumed() const = 0;
 
+  // Returns true if the request should be considered idle, for the purposes of
+  // IsConnectedAndIdle.
+  virtual bool IsIdle() const;
+
   // Accessor for the socket which is using the SocketDataProvider.
   AsyncSocket* socket() { return socket_; }
   void set_socket(AsyncSocket* socket) { socket_ = socket; }
 
   MockConnect connect_data() const { return connect_; }
   void set_connect_data(const MockConnect& connect) { connect_ = connect; }
 
  private:
   MockConnect connect_;
   AsyncSocket* socket_;
@@ skipping 11 matching lines @@
   // data.async is ignored, and this read is completed synchronously as
   // part of this call.
   // TODO(rch): this should take a StringPiece since most of the fields
   // are ignored.
   virtual void OnReadComplete(const MockRead& data) = 0;
   // If an async IO is pending because the SocketDataProvider returned
   // ERR_IO_PENDING, then the AsyncSocket waits until this OnReadComplete
   // is called to complete the asynchronous read operation.
   virtual void OnWriteComplete(int rv) = 0;
   virtual void OnConnectComplete(const MockConnect& data) = 0;
+
+  // Called when the SocketDataProvider associated with the socket is destroyed.
+  // The socket may continue to be used after the data provider is destroyed,
+  // so it should be sure not to dereference the provider after this is called.
+  virtual void OnDataProviderDestroyed() = 0;

[mmenke, 2015/12/03 19:37:10]

Could use weak ptrs instead, but I think this is a bit more flexible.  Could
make this cancel pending callbacks or something in the future.

 };
 
 // StaticSocketDataHelper manages a list of reads and writes.
 class StaticSocketDataHelper {
  public:
   StaticSocketDataHelper(MockRead* reads,
                          size_t reads_count,
                          MockWrite* writes,
                          size_t writes_count);
   ~StaticSocketDataHelper();
@@ skipping 109 matching lines @@
                       size_t writes_count);
 
   ~SequencedSocketData() override;
 
   // SocketDataProviderBase implementation.
   MockRead OnRead() override;
   MockWriteResult OnWrite(const std::string& data) override;
   void Reset() override;
   bool AllReadDataConsumed() const override;
   bool AllWriteDataConsumed() const override;
+  bool IsIdle() const override;
 
   bool IsReadPaused();
   void CompleteRead();
 
+  // When true, IsConnectedAndIdle() will return false if the next event in the
+  // sequence is a synchronous.  Otherwise, the socket claims to be idle as
+  // long as it's connected.  Defaults to false.
+  void set_busy_before_sync_reads(bool busy_before_sync_reads) {
+    busy_before_sync_reads_ = busy_before_sync_reads;
+  }
+
  private:
   // Defines the state for the read or write path.
   enum IoState {
     IDLE,        // No async operation is in progress.
     PENDING,     // An async operation in waiting for another opteration to
                  // complete.
     COMPLETING,  // A task has been posted to complet an async operation.
     PAUSED,      // IO is paused until CompleteRead() is called.
   };
 
   void OnReadComplete();
   void OnWriteComplete();
 
   void MaybePostReadCompleteTask();
   void MaybePostWriteCompleteTask();
 
   StaticSocketDataHelper helper_;
   int sequence_number_;
   IoState read_state_;
   IoState write_state_;
 
+  bool busy_before_sync_reads_;
+
   base::WeakPtrFactory<SequencedSocketData> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedSocketData);
 };
 
 class DeterministicMockTCPClientSocket;
 
 // This class gives the user full control over the network activity,
 // specifically the timing of the COMPLETION of I/O operations.  Regardless of
 // the order in which I/O operations are initiated, this class ensures that they
@@ skipping 308 matching lines @@
   bool WasNpnNegotiated() const 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;
 
  private:
   int CompleteRead();
 
   AddressList addresses_;
 
   SocketDataProvider* data_;
   int read_offset_;
   MockRead read_data_;
   bool need_read_data_;
@@ skipping 161 matching lines @@
            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;
   bool UsingTCPFastOpen() const override;
   int GetPeerAddress(IPEndPoint* address) const override;
   bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // SSLClientSocket implementation.
   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override;
   NextProtoStatus GetNextProto(std::string* proto) const override;
 
   // This MockSocket does not implement the manual async IO feature.
   void OnReadComplete(const MockRead& data) override;
   void OnWriteComplete(int rv) override;
   void OnConnectComplete(const MockConnect& data) override;
+  // SSL sockets don't need magic to deal with destruction of their data
+  // provider.
+  // TODO(mmenke):  Probably a good idea to support it, anyways.
+  void OnDataProviderDestroyed() override {}
 
   ChannelIDService* GetChannelIDService() const override;
 
  private:
   static void ConnectCallback(MockSSLClientSocket* ssl_client_socket,
                               const CompletionCallback& callback,
                               int rv);
 
   scoped_ptr<ClientSocketHandle> transport_;
   SSLSocketDataProvider* data_;
@@ skipping 23 matching lines @@
   const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
   int BindToNetwork(NetworkChangeNotifier::NetworkHandle network) override;
   int Connect(const IPEndPoint& address) override;
 
   // AsyncSocket implementation.
   void OnReadComplete(const MockRead& data) override;
   void OnWriteComplete(int rv) override;
   void OnConnectComplete(const MockConnect& data) override;
+  void OnDataProviderDestroyed() override;
 
   void set_source_port(uint16 port) { source_port_ = port;}
 
  private:
   int CompleteRead();
 
   void RunCallbackAsync(const CompletionCallback& callback, int result);
   void RunCallback(const CompletionCallback& callback, int result);
 
   bool connected_;
@@ skipping 281 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_