Drop buffers in idle SSLClientSockets (and SSLServerSockets).

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 262 matching lines @@
 
 // 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();
 
-  // These functions get access to the next available read and write data,
-  // or null if there is no more data available.
+  // These functions get access to the next available read and write data. They
+  // CHECK fail if there is no data available.
   const MockRead& PeekRead() const;
   const MockWrite& PeekWrite() const;
 
-  // Returns the current read or write , and then advances to the next one.
+  // Returns the current read or write, and then advances to the next one.
   const MockRead& AdvanceRead();
   const MockWrite& AdvanceWrite();
 
   // Resets the read and write indexes to 0.
   void Reset();
 
   // Returns true if |data| is valid data for the next write. In order
   // to support short writes, the next write may be longer than |data|
   // in which case this method will still return true.
   bool VerifyWriteData(const std::string& data);
 
   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 AllReadDataConsumed() const { return read_index_ >= read_count_; }
   bool AllWriteDataConsumed() const { return write_index_ >= write_count_; }
 
  private:
+  // Returns the next available read or write that is not a pause event. CHECK
+  // fails if no data is available.
+  const MockWrite& PeekRealWrite() const;
+
   MockRead* reads_;
   size_t read_index_;
   size_t read_count_;
   MockWrite* writes_;
   size_t write_index_;
   size_t write_count_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSocketDataHelper);
 };
 
@@ skipping 106 matching lines @@
   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.
+    COMPLETING,  // A task has been posted to complete an async operation.
     PAUSED,      // IO is paused until Resume() is called.
   };
 
   // From SocketDataProvider:
   void Reset() override;
 
   void OnReadComplete();
   void OnWriteComplete();
 
   void MaybePostReadCompleteTask();
@@ skipping 565 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_