[GCM] Investigatory CHECKs for crash in parsing stream

google_apis/gcm/engine/connection_handler_impl.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/engine/connection_handler_impl.h"
 
 #include "base/message_loop/message_loop.h"
 #include "google/protobuf/io/coded_stream.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/base/socket_stream.h"
@@ skipping 166 matching lines @@
     int last_error = output_stream_->last_error();
     CloseConnection();
     // If the socket stream had an error, plumb it up, else plumb up FAILED.
     if (last_error == net::OK)
       last_error = net::ERR_FAILED;
     connection_callback_.Run(last_error);
     return;
   }
 
   // Used to determine whether a Socket::Read is necessary.
-  size_t min_bytes_needed = 0;
+  int min_bytes_needed = 0;
   // Used to limit the size of the Socket::Read.
-  size_t max_bytes_needed = 0;
+  int max_bytes_needed = 0;
 
   switch(state) {
     case MCS_VERSION_TAG_AND_SIZE:
       min_bytes_needed = kVersionPacketLen + kTagPacketLen + kSizePacketLenMin;
       max_bytes_needed = kVersionPacketLen + kTagPacketLen + kSizePacketLenMax;
       break;
     case MCS_TAG_AND_SIZE:
       min_bytes_needed = kTagPacketLen + kSizePacketLenMin;
       max_bytes_needed = kTagPacketLen + kSizePacketLenMax;
       break;
     case MCS_FULL_SIZE:
       // If in this state, the minimum size packet length must already have been
       // insufficient, so set both to the max length.
       min_bytes_needed = kSizePacketLenMax;
       max_bytes_needed = kSizePacketLenMax;
       break;
     case MCS_PROTO_BYTES:
       read_timeout_timer_.Reset();
       // No variability in the message size, set both to the same.
       min_bytes_needed = message_size_;
       max_bytes_needed = message_size_;
       break;
     default:
       NOTREACHED();
   }
   DCHECK_GE(max_bytes_needed, min_bytes_needed);
 
-  size_t unread_byte_count = input_stream_->UnreadByteCount();
+  int unread_byte_count = input_stream_->UnreadByteCount();
   if (min_bytes_needed > unread_byte_count &&
       input_stream_->Refresh(
           base::Bind(&ConnectionHandlerImpl::WaitForData,
                      weak_ptr_factory_.GetWeakPtr(),
                      state),
           max_bytes_needed - unread_byte_count) == net::ERR_IO_PENDING) {
     return;
   }
 
   // Check for refresh errors.
@@ skipping 190 matching lines @@
   socket_ = NULL;
   handshake_complete_ = false;
   message_tag_ = 0;
   message_size_ = 0;
   input_stream_.reset();
   output_stream_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace gcm