Drop buffers in idle SSLClientSockets (and SSLServerSockets).

net/socket/socket_test_util.cc

 // 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.
 
 #include "net/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 183 matching lines @@
 const MockRead& StaticSocketDataHelper::AdvanceRead() {
   CHECK(!AllReadDataConsumed());
   return reads_[read_index_++];
 }
 
 const MockWrite& StaticSocketDataHelper::AdvanceWrite() {
   CHECK(!AllWriteDataConsumed());
   return writes_[write_index_++];
 }
 
+void StaticSocketDataHelper::Reset() {
+  read_index_ = 0;
+  write_index_ = 0;
+}

[mmenke, 2016/10/14 14:57:39]

If this isn't being used, should be just remove it instead?

[davidben, 2016/10/14 16:32:37]

Seems to be called in initialization. I was just reordering to match the header.

[mmenke, 2016/10/14 16:45:32]

Oops, didn't notice that you moved it, as opposed to adding it.

+
 bool StaticSocketDataHelper::VerifyWriteData(const std::string& data) {
   CHECK(!AllWriteDataConsumed());
-  // Check that what the actual data matches the expectations.
-  const MockWrite& next_write = PeekWrite();
+  // Check that the actual data matches the expectations, skipping over any
+  // pause events.
+  const MockWrite& next_write = PeekRealWrite();
   if (!next_write.data)
     return true;
 
   // Note: Partial writes are supported here.  If the expected data
   // is a match, but shorter than the write actually written, that is legal.
   // Example:
   //   Application writes "foobarbaz" (9 bytes)
   //   Expected write was "foo" (3 bytes)
   //   This is a success, and the function returns true.
   std::string expected_data(next_write.data, next_write.data_len);
   std::string actual_data(data.substr(0, next_write.data_len));
   EXPECT_GE(data.length(), expected_data.length());
   EXPECT_EQ(expected_data, actual_data);
   return expected_data == actual_data;
 }
 
-void StaticSocketDataHelper::Reset() {
-  read_index_ = 0;
-  write_index_ = 0;
+const MockWrite& StaticSocketDataHelper::PeekRealWrite() const {
+  for (size_t i = write_index_; i < write_count_; i++) {
+    if (writes_[i].mode != ASYNC || writes_[i].result != ERR_IO_PENDING)
+      return writes_[i];
+  }
+
+  CHECK(0) << "No write data available.";

[mmenke, 2016/10/14 14:57:39]

nit:  CHECK(false) is more common.

[davidben, 2016/10/14 16:32:37]

Done. C habits. :-)

+  return writes_[0];  // Avoid warning about unreachable missing return.
 }
 
 StaticSocketDataProvider::StaticSocketDataProvider()
     : StaticSocketDataProvider(nullptr, 0, nullptr, 0) {
 }
 
 StaticSocketDataProvider::StaticSocketDataProvider(MockRead* reads,
                                                    size_t reads_count,
                                                    MockWrite* writes,
                                                    size_t writes_count)
@@ skipping 1496 matching lines @@
 }
 
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
   int64_t total = 0;
   for (const MockWrite* write = writes; write != writes + writes_size; ++write)
     total += write->data_len;
   return total;
 }
 
 }  // namespace net