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 186 matching lines @@
   // 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 140 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 even 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) {

[asanka, 2015/12/03 17:41:57]

Perhaps not for this CL, but shouldn't this always be true? The
IsConnectedAndIdle() test is basically looking for whether the next read will
succeed synchronously.

[mmenke, 2015/12/03 18:24:23]

I was worried about breaking all existing synchronous tests that check socket
reuse cases, but I suppose those would generally have a write before the read. 
I'll experiment with it in a followup CL, and see how things look.

+    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 489 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.
@@ skipping 337 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_