Add bounds checking to StaticSocketDataProvider, to make tests more reliable

net/socket/socket_test_util.cc

 // Copyright (c) 2009 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 "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 266 matching lines @@
                               net::CompletionCallback* callback) {
   return transport_->Read(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* callback) {
   return transport_->Write(buf, buf_len, callback);
 }
 
 MockRead StaticSocketDataProvider::GetNextRead() {
-  MockRead rv = reads_[read_index_];
-  if (reads_[read_index_].result != OK ||
-      reads_[read_index_].data_len != 0)
-    read_index_++;  // Don't advance past an EOF.
-  return rv;
+  DCHECK(!at_read_eof());
+  return reads_[read_index_++];
 }
 
 MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
   if (!writes_) {
     // Not using mock writes; succeed synchronously.
     return MockWriteResult(false, data.length());
   }
 
+  DCHECK(!at_write_eof());
+
   // Check that what we are writing matches the expectation.
   // Then give the mocked return value.
   net::MockWrite* w = &writes_[write_index_++];
   int result = w->result;
   if (w->data) {
     // Note - we can simulate a partial write 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)
@@ skipping 153 matching lines @@
 }
 
 void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) {
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 }  // namespace net