[GCM] Investigatory CHECKs for crash in parsing stream

google_apis/gcm/base/socket_stream.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/bind.h"
 #include "base/callback.h"
 #include "net/base/io_buffer.h"
 #include "net/socket/stream_socket.h"
@@ skipping 38 matching lines @@
   DCHECK_LT(next_pos_, read_buffer_->BytesConsumed());
   *data = io_buffer_->data() + next_pos_;
   *size = UnreadByteCount();
   next_pos_ = read_buffer_->BytesConsumed();
   DVLOG(1) << "Consuming " << *size << " bytes in input buffer.";
   return true;
 }
 
 void SocketInputStream::BackUp(int count) {
   DCHECK(GetState() == READY || GetState() == EMPTY);
-  DCHECK_GT(count, 0);
-  DCHECK_LE(count, next_pos_);
+  // TODO(zea): investigating crbug.com/409985
+  CHECK_GT(count, 0);
+  CHECK_LE(count, next_pos_);
 
   next_pos_ -= count;
   DVLOG(1) << "Backing up " << count << " bytes in input buffer. "
            << "Current position now at " << next_pos_
            << " of " << read_buffer_->BytesConsumed();
 }
 
 bool SocketInputStream::Skip(int count) {
   NOTIMPLEMENTED();
   return false;
 }
 
 int64 SocketInputStream::ByteCount() const {
   DCHECK_NE(GetState(), CLOSED);
   DCHECK_NE(GetState(), READING);
   return next_pos_;
 }
 
-size_t SocketInputStream::UnreadByteCount() const {
+int SocketInputStream::UnreadByteCount() const {
   DCHECK_NE(GetState(), CLOSED);
   DCHECK_NE(GetState(), READING);
   return read_buffer_->BytesConsumed() - next_pos_;
 }
 
 net::Error SocketInputStream::Refresh(const base::Closure& callback,
                                       int byte_limit) {
   DCHECK_NE(GetState(), CLOSED);
   DCHECK_NE(GetState(), READING);
   DCHECK_GT(byte_limit, 0);
@@ skipping 40 matching lines @@
 
   if (unread_data_ptr != io_buffer_->data()) {
     DVLOG(1) << "Have " << unread_data_size
              << " unread bytes remaining, shifting.";
     // Move any remaining unread data to the start of the buffer;
     std::memmove(io_buffer_->data(), unread_data_ptr, unread_data_size);
   } else {
     DVLOG(1) << "Have " << unread_data_size << " unread bytes remaining.";
   }
   read_buffer_->DidConsume(unread_data_size);
+  // TODO(zea): investigating crbug.com/409985
+  CHECK_GE(UnreadByteCount(), 0);
 }
 
 net::Error SocketInputStream::last_error() const {
   return last_error_;
 }
 
 SocketInputStream::State SocketInputStream::GetState() const {
   if (last_error_ < net::ERR_IO_PENDING)
     return CLOSED;
 
@@ skipping 22 matching lines @@
 
   if (result < net::OK) {
     DVLOG(1) << "Failed to refresh socket: " << result;
     CloseStream(static_cast<net::Error>(result), callback);
     return;
   }
 
   DCHECK_GT(result, 0);
   last_error_ = net::OK;
   read_buffer_->DidConsume(result);
+  // TODO(zea): investigating crbug.com/409985
+  CHECK_GT(UnreadByteCount(), 0);
 
   DVLOG(1) << "Refresh complete with " << result << " new bytes. "
            << "Current position " << next_pos_
            << " of " << read_buffer_->BytesConsumed() << ".";
 
   if (!callback.is_null())
     callback.Run();
 }
 
 void SocketInputStream::ResetInternal() {
@@ skipping 131 matching lines @@
   }
 
   DVLOG(1) << "Socket flush complete.";
   write_buffer_->SetOffset(0);
   next_pos_ = 0;
   if (!callback.is_null())
     callback.Run();
 }
 
 }  // namespace gcm