Add bounds checking to StaticSocketDataProvider, to make tests more reliable

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2010 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/spdy/spdy_network_transaction.h"
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_log_unittest.h"
@@ skipping 66 matching lines @@
                                 &session_deps->socket_factory,
                                 session_deps->ssl_config_service,
                                 session_deps->flip_session_pool);
 }
 
 // Chop a frame into an array of MockWrites.
 // |data| is the frame to chop.
 // |length| is the length of the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockWrite* ChopFrame(const char* data, int length, int num_chunks) {
-  MockWrite* chunks = new MockWrite[num_chunks + 1];
+  MockWrite* chunks = new MockWrite[num_chunks];
   int chunk_size = length / num_chunks;
   for (int index = 0; index < num_chunks; index++) {
     const char* ptr = data + (index * chunk_size);
     if (index == num_chunks - 1)
       chunk_size += length % chunk_size;  // The last chunk takes the remainder.
     chunks[index] = MockWrite(true, ptr, chunk_size);
   }
-  chunks[num_chunks] = MockWrite(true, 0, 0);
   return chunks;
 }
 
 // ----------------------------------------------------------------------------
 
 static const unsigned char kGetSyn[] = {
   0x80, 0x01, 0x00, 0x01,                                        // header
   0x01, 0x00, 0x00, 0x45,                                        // FIN, len
   0x00, 0x00, 0x00, 0x01,                                        // stream id
   0xc0, 0x00, 0x00, 0x03,                                        // 4 headers
@@ skipping 85 matching lines @@
   'h', 'e', 'l', 'l', 'o', '!',                                  // "hello"
 };
 
 }  // namespace
 
 // A DataProvider where the client must write a request before the reads (e.g.
 // the response) will complete.
 class DelayedSocketData : public StaticSocketDataProvider,
                           public base::RefCounted<DelayedSocketData> {
  public:
-  // |reads| the list of MockRead completions.
   // |write_delay| the number of MockWrites to complete before allowing
   //               a MockRead to complete.
+  // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
   // Note: The MockRead and MockWrite lists musts end with a EOF
   //       e.g. a MockRead(true, 0, 0);
-  DelayedSocketData(MockRead* reads, int write_delay, MockWrite* writes)
-    : StaticSocketDataProvider(reads, writes),
+  DelayedSocketData(int write_delay,
+                    MockRead* reads, size_t reads_count,
+                    MockWrite* writes, size_t writes_count)
+    : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
     DCHECK_GE(write_delay_, 0);
   }
 
   // |connect| the result for the connect phase.
   // |reads| the list of MockRead completions.
   // |write_delay| the number of MockWrites to complete before allowing
   //               a MockRead to complete.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
   // Note: The MockRead and MockWrite lists musts end with a EOF
   //       e.g. a MockRead(true, 0, 0);
-  DelayedSocketData(const MockConnect& connect, MockRead* reads,
-                    int write_delay, MockWrite* writes)
-    : StaticSocketDataProvider(reads, writes),
+  DelayedSocketData(const MockConnect& connect, int write_delay,
+                    MockRead* reads, size_t reads_count,
+                    MockWrite* writes, size_t writes_count)
+    : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
     DCHECK_GE(write_delay_, 0);
     set_connect_data(connect);
   }
 
   virtual MockRead GetNextRead() {
     if (write_delay_)
       return MockRead(true, ERR_IO_PENDING);
     return StaticSocketDataProvider::GetNextRead();
@@ skipping 102 matching lines @@
   SessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session =
       CreateSession(&session_deps);
   scoped_ptr<HttpTransaction> trans(new FlipNetworkTransaction(session));
 }
 
 TEST_F(FlipNetworkTransactionTest, Get) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
               arraysize(kGetSyn)),
-    MockWrite(true, 0, 0)  // EOF
   };
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
              arraysize(kGetSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
-      new DelayedSocketData(reads, 1, writes));
+      new DelayedSocketData(1, reads, arraysize(reads),
+                            writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_F(FlipNetworkTransactionTest, Post) {
   static const char upload[] = { "hello world" };
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data = new UploadData();
   request.upload_data->AppendBytes(upload, sizeof(upload));
 
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kPostSyn),
               arraysize(kPostSyn)),
     MockWrite(true, reinterpret_cast<const char*>(kPostUploadFrame),
               arraysize(kPostUploadFrame)),
-    MockWrite(true, 0, 0)  // EOF
   };
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kPostSynReply),
              arraysize(kPostSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kPostBodyFrame),
              arraysize(kPostBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
-      new DelayedSocketData(reads, 2, writes));
+      new DelayedSocketData(2, reads, arraysize(reads),
+                            writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_F(FlipNetworkTransactionTest, EmptyPost) {
 static const unsigned char kEmptyPostSyn[] = {
   0x80, 0x01, 0x00, 0x01,                                      // header
@@ skipping 13 matching lines @@
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   // Create an empty UploadData.
   request.upload_data = new UploadData();
 
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kEmptyPostSyn),
               arraysize(kEmptyPostSyn)),
-    MockWrite(true, 0, 0)  // EOF
   };
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kPostSynReply),
              arraysize(kPostSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kPostBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
-    new DelayedSocketData(reads, 1, writes));
+    new DelayedSocketData(1, reads, arraysize(reads),
+                          writes, arraysize(writes)));
 
   TransactionHelperResult out = TransactionHelper(request, data, NULL);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_F(FlipNetworkTransactionTest, ResponseWithoutSynReply) {
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kPostBodyFrame),
              arraysize(kPostBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
-      new DelayedSocketData(reads, 1, NULL));
+      new DelayedSocketData(1, reads, arraysize(reads), NULL, 0));
   TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
 }
 
 TEST_F(FlipNetworkTransactionTest, CancelledTransaction) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
               arraysize(kGetSyn)),
     MockRead(true, 0, 0)  // EOF
   };
@@ skipping 13 matching lines @@
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   // We disable SSL for this test.
   FlipSession::SetSSLMode(false);
 
   SessionDependencies session_deps;
   scoped_ptr<FlipNetworkTransaction> trans(
       new FlipNetworkTransaction(CreateSession(&session_deps)));
 
-  StaticSocketDataProvider data(reads, writes);
+  StaticSocketDataProvider data(reads, arraysize(reads),
+                                writes, arraysize(writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   trans.reset();  // Cancel the transaction.
 
   // Flush the MessageLoop while the SessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
@@ skipping 77 matching lines @@
       "status: 200\n"
       "url: /index.php\n"
       "version: HTTP/1.1\n"
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     MockWrite writes[] = {
       MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
                 arraysize(kGetSyn)),
-      MockWrite(true, 0, 0)  // EOF
     };
 
     MockRead reads[] = {
       MockRead(true, reinterpret_cast<const char*>(test_cases[i].syn_reply),
                test_cases[i].syn_reply_length),
       MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
                arraysize(kGetBodyFrame)),
       MockRead(true, 0, 0)  // EOF
     };
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
     scoped_refptr<DelayedSocketData> data(
-        new DelayedSocketData(reads, 1, writes));
+        new DelayedSocketData(1, reads, arraysize(reads),
+                              writes, arraysize(writes)));
     TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
     EXPECT_EQ(OK, out.rv);
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
 
     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
     EXPECT_TRUE(headers.get() != NULL);
     void* iter = NULL;
     std::string name, value, lines;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
@@ skipping 54 matching lines @@
       MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
                arraysize(kGetBodyFrame)),
       MockRead(true, 0, 0)  // EOF
     };
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
     scoped_refptr<DelayedSocketData> data(
-        new DelayedSocketData(reads, 1, writes));
+        new DelayedSocketData(1, reads, arraysize(reads),
+                              writes, arraysize(writes)));
     TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
     EXPECT_EQ(ERR_INVALID_RESPONSE, out.rv);
   }
 }
 
 // Verify that we don't crash on some corrupt frames.
 TEST_F(FlipNetworkTransactionTest, CorruptFrameSessionError) {
   static const unsigned char kSynReplyMassiveLength[] = {
     0x80, 0x01, 0x00, 0x02,
     0x0f, 0x11, 0x11, 0x26,   // This is the length field with a big number
@@ skipping 25 matching lines @@
       MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
                arraysize(kGetBodyFrame)),
       MockRead(true, 0, 0)  // EOF
     };
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
     scoped_refptr<DelayedSocketData> data(
-        new DelayedSocketData(reads, 1, writes));
+        new DelayedSocketData(1, reads, arraysize(reads),
+                              writes, arraysize(writes)));
     TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
     EXPECT_EQ(ERR_FLIP_PROTOCOL_ERROR, out.rv);
   }
 }
 
 TEST_F(FlipNetworkTransactionTest, ServerPush) {
   // Reply with the X-Associated-Content header.
   static const unsigned char syn_reply[] = {
     0x80, 0x01, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x71,
@@ skipping 31 matching lines @@
   // Body for stream 2
   static const unsigned char body_frame_2[] = {
     0x00, 0x00, 0x00, 0x02,
     0x01, 0x00, 0x00, 0x07,
     'g', 'o', 'o', 'd', 'b', 'y', 'e',
   };
 
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
               arraysize(kGetSyn)),
-    MockWrite(true, 0, 0)  // EOF
   };
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(syn_reply),
              arraysize(syn_reply)),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, ERR_IO_PENDING),  // Force a pause
     MockRead(true, reinterpret_cast<const char*>(syn_push),
              arraysize(syn_push)),
@@ skipping 16 matching lines @@
     // deliver the data when the client does make the request.
     PUSH_BEFORE_REQUEST,
     DONE
   };
 
   for (int test_type = PUSH_AFTER_REQUEST; test_type != DONE; ++test_type) {
     // Setup a mock session.
     SessionDependencies session_deps;
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
     scoped_refptr<DelayedSocketData> data(
-        new DelayedSocketData(reads, 1, writes));
+        new DelayedSocketData(1, reads, arraysize(reads),
+                              writes, arraysize(writes)));
     session_deps.socket_factory.AddSocketDataProvider(data.get());
 
     // Issue the first request
     {
       FlipNetworkTransaction trans(session.get());
 
       // Issue the first request.
       HttpRequestInfo request;
       request.method = "GET";
       request.url = GURL("http://www.google.com/");
@@ skipping 76 matching lines @@
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
-      new DelayedSocketData(reads, 2, writes));
+      new DelayedSocketData(2, reads, arraysize(reads),
+                            writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
   EXPECT_EQ(ERR_FAILED, out.rv);
   data->Reset();
 }
 
 // Test that partial writes work.
 TEST_F(FlipNetworkTransactionTest, PartialWrite) {
   // Chop the SYN_STREAM frame into 5 chunks.
   const int kChunks = 5;
   scoped_array<MockWrite> writes(ChopFrame(
       reinterpret_cast<const char*>(kGetSyn), arraysize(kGetSyn), kChunks));
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
              arraysize(kGetSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
-      new DelayedSocketData(reads, kChunks, writes.get()));
+      new DelayedSocketData(kChunks, reads, arraysize(reads),
+                            writes.get(), kChunks));
   TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 TEST_F(FlipNetworkTransactionTest, DISABLED_ConnectFailure) {
   MockConnect connects[]  = {
     MockConnect(true, ERR_NAME_NOT_RESOLVED),
     MockConnect(false, ERR_NAME_NOT_RESOLVED),
@@ skipping 14 matching lines @@
       MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
                arraysize(kGetBodyFrame)),
       MockRead(true, 0, 0)  // EOF
     };
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
     scoped_refptr<DelayedSocketData> data(
-        new DelayedSocketData(connects[index], reads, 1, writes));
+        new DelayedSocketData(connects[index], 1, reads, arraysize(reads),
+                              writes, arraysize(writes)));
     TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
     EXPECT_EQ(connects[index].result, out.rv);
   }
 }
 
 // In this test, we enable compression, but get a uncompressed SynReply from
 // the server.  Verify that teardown is all clean.
 TEST_F(FlipNetworkTransactionTest, DecompressFailureOnSynReply) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSynCompressed),
@@ skipping 10 matching lines @@
   };
 
   // For this test, we turn on the normal compression.
   EnableCompression(true);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
-      new DelayedSocketData(reads, 1, writes));
+      new DelayedSocketData(1, reads, arraysize(reads),
+                            writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
   data->Reset();
 
   EnableCompression(false);
 }
 
 // Test that the LoadLog contains good data for a simple GET request.
 TEST_F(FlipNetworkTransactionTest, LoadLog) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
               arraysize(kGetSyn)),
-    MockWrite(true, 0, 0)  // EOF
   };
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
              arraysize(kGetSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<net::LoadLog> log(new net::LoadLog(net::LoadLog::kUnbounded));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
-      new DelayedSocketData(reads, 1, writes));
+      new DelayedSocketData(1, reads, arraysize(reads),
+                            writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelper(request, data.get(),
                                                   log);
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   // Check that the LoadLog was filled reasonably.
   // This test is intentionally non-specific about the exact ordering of
   // the log; instead we just check to make sure that certain events exist.
   EXPECT_LT(0u, log->entries().size());
@@ skipping 20 matching lines @@
       net::LoadLog::PHASE_END);
   pos = net::ExpectLogContainsSomewhere(log, pos + 1,
       net::LoadLog::TYPE_FLIP_TRANSACTION_READ_BODY,
       net::LoadLog::PHASE_BEGIN);
   pos = net::ExpectLogContainsSomewhere(log, pos + 1,
       net::LoadLog::TYPE_FLIP_TRANSACTION_READ_BODY,
       net::LoadLog::PHASE_END);
 }
 
 }  // namespace net