[GCM] Investigatory CHECKs for crash in parsing stream

google_apis/gcm/base/socket_stream_unittest.cc

 // Copyright 2013 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 "google_apis/gcm/base/socket_stream.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 namespace {
 
 typedef std::vector<net::MockRead> ReadList;
 typedef std::vector<net::MockWrite> WriteList;
 
 const char kReadData[] = "read_data";
-const uint64 kReadDataSize = arraysize(kReadData) - 1;
+const int kReadDataSize = arraysize(kReadData) - 1;
 const char kReadData2[] = "read_alternate_data";
-const uint64 kReadData2Size = arraysize(kReadData2) - 1;
+const int kReadData2Size = arraysize(kReadData2) - 1;
 const char kWriteData[] = "write_data";
-const uint64 kWriteDataSize = arraysize(kWriteData) - 1;
+const int kWriteDataSize = arraysize(kWriteData) - 1;
 
 class GCMSocketStreamTest : public testing::Test {
  public:
   GCMSocketStreamTest();
   virtual ~GCMSocketStreamTest();
 
   // Build a socket with the expected reads and writes.
   void BuildSocket(const ReadList& read_list, const WriteList& write_list);
 
   // Pump the message loop until idle.
   void PumpLoop();
 
   // Simulates a google::protobuf::io::CodedInputStream read.
-  base::StringPiece DoInputStreamRead(uint64 bytes);
+  base::StringPiece DoInputStreamRead(int bytes);
   // Simulates a google::protobuf::io::CodedOutputStream write.
-  uint64 DoOutputStreamWrite(const base::StringPiece& write_src);
+  int DoOutputStreamWrite(const base::StringPiece& write_src);
 
   // Synchronous Refresh wrapper.
-  void WaitForData(size_t msg_size);
+  void WaitForData(int msg_size);
 
   base::MessageLoop* message_loop() { return &message_loop_; };
   net::DelayedSocketData* data_provider() { return data_provider_.get(); }
   SocketInputStream* input_stream() { return socket_input_stream_.get(); }
   SocketOutputStream* output_stream() { return socket_output_stream_.get(); }
   net::StreamSocket* socket() { return socket_.get(); }
 
  private:
   void OpenConnection();
   void ResetInputStream();
@@ skipping 37 matching lines @@
   OpenConnection();
   ResetInputStream();
   ResetOutputStream();
 }
 
 void GCMSocketStreamTest::PumpLoop() {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 }
 
-base::StringPiece GCMSocketStreamTest::DoInputStreamRead(uint64 bytes) {
-  uint64 total_bytes_read = 0;
+base::StringPiece GCMSocketStreamTest::DoInputStreamRead(int bytes) {
+  int total_bytes_read = 0;
   const void* initial_buffer = NULL;
   const void* buffer = NULL;
   int size = 0;
 
   do {
     DCHECK(socket_input_stream_->GetState() == SocketInputStream::EMPTY ||
            socket_input_stream_->GetState() == SocketInputStream::READY);
     if (!socket_input_stream_->Next(&buffer, &size))
       break;
     total_bytes_read += size;
     if (initial_buffer) {  // Verify the buffer doesn't skip data.
       EXPECT_EQ(static_cast<const uint8*>(initial_buffer) + total_bytes_read,
                 static_cast<const uint8*>(buffer) + size);
     } else {
       initial_buffer = buffer;
     }
   } while (total_bytes_read < bytes);
 
   if (total_bytes_read > bytes) {
     socket_input_stream_->BackUp(total_bytes_read - bytes);
     total_bytes_read = bytes;
   }
 
   return base::StringPiece(static_cast<const char*>(initial_buffer),
                            total_bytes_read);
 }
 
-uint64 GCMSocketStreamTest::DoOutputStreamWrite(
+int GCMSocketStreamTest::DoOutputStreamWrite(
     const base::StringPiece& write_src) {
   DCHECK_EQ(socket_output_stream_->GetState(), SocketOutputStream::EMPTY);
-  uint64 total_bytes_written = 0;
+  int total_bytes_written = 0;
   void* buffer = NULL;
   int size = 0;
-  size_t bytes = write_src.size();
+  int bytes = write_src.size();
 
   do {
     if (!socket_output_stream_->Next(&buffer, &size))
       break;
-    uint64 bytes_to_write = (static_cast<uint64>(size) < bytes ? size : bytes);
+    int bytes_to_write = (size < bytes ? size : bytes);
     memcpy(buffer,
            write_src.data() + total_bytes_written,
            bytes_to_write);
-    if (bytes_to_write < static_cast<uint64>(size))
+    if (bytes_to_write < size)
       socket_output_stream_->BackUp(size - bytes_to_write);
     total_bytes_written += bytes_to_write;
   } while (total_bytes_written < bytes);
 
   base::RunLoop run_loop;
   if (socket_output_stream_->Flush(run_loop.QuitClosure()) ==
           net::ERR_IO_PENDING) {
     run_loop.Run();
   }
 
   return total_bytes_written;
 }
 
-void GCMSocketStreamTest::WaitForData(size_t msg_size) {
+void GCMSocketStreamTest::WaitForData(int msg_size) {
   while (input_stream()->UnreadByteCount() < msg_size) {
     base::RunLoop run_loop;
     if (input_stream()->Refresh(run_loop.QuitClosure(),
                                 msg_size - input_stream()->UnreadByteCount()) ==
             net::ERR_IO_PENDING) {
       run_loop.Run();
     }
     if (input_stream()->GetState() == SocketInputStream::CLOSED)
       return;
   }
@@ skipping 27 matching lines @@
                                         kReadDataSize)),
               WriteList());
 
   WaitForData(kReadDataSize);
   ASSERT_EQ(std::string(kReadData, kReadDataSize),
             DoInputStreamRead(kReadDataSize));
 }
 
 // A read that comes in two parts.
 TEST_F(GCMSocketStreamTest, ReadPartialDataSync) {
-  size_t first_read_len = kReadDataSize / 2;
-  size_t second_read_len = kReadDataSize - first_read_len;
+  int first_read_len = kReadDataSize / 2;
+  int second_read_len = kReadDataSize - first_read_len;
   ReadList read_list;
   read_list.push_back(
       net::MockRead(net::SYNCHRONOUS,
                     kReadData,
                     first_read_len));
   read_list.push_back(
       net::MockRead(net::SYNCHRONOUS,
                     &kReadData[first_read_len],
                     second_read_len));
   BuildSocket(read_list, WriteList());
 
   WaitForData(kReadDataSize);
   ASSERT_EQ(std::string(kReadData, kReadDataSize),
             DoInputStreamRead(kReadDataSize));
 }
 
 // A read where no data is available at first (IO_PENDING will be returned).
 TEST_F(GCMSocketStreamTest, ReadAsync) {
-  size_t first_read_len = kReadDataSize / 2;
-  size_t second_read_len = kReadDataSize - first_read_len;
+  int first_read_len = kReadDataSize / 2;
+  int second_read_len = kReadDataSize - first_read_len;
   ReadList read_list;
   read_list.push_back(
       net::MockRead(net::SYNCHRONOUS, net::ERR_IO_PENDING));
   read_list.push_back(
       net::MockRead(net::ASYNC, kReadData, first_read_len));
   read_list.push_back(
       net::MockRead(net::ASYNC, &kReadData[first_read_len], second_read_len));
   BuildSocket(read_list, WriteList());
 
   base::MessageLoop::current()->PostTask(
@@ skipping 155 matching lines @@
 TEST_F(GCMSocketStreamTest, WriteDisconnected) {
   BuildSocket(ReadList(), WriteList());
   socket()->Disconnect();
   DoOutputStreamWrite(base::StringPiece(kWriteData, kWriteDataSize));
   ASSERT_EQ(SocketOutputStream::CLOSED, output_stream()->GetState());
   ASSERT_EQ(net::ERR_CONNECTION_CLOSED, output_stream()->last_error());
 }
 
 }  // namespace
 }  // namespace gcm