Tighten up compile warnings based to match other chromium sub-projects....

remoting/base/protocol_decoder.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 "remoting/base/protocol_decoder.h"
 
 #include "remoting/base/multiple_array_input_stream.h"
 #include "talk/base/byteorder.h"
 
 namespace remoting {
@@ skipping 51 matching lines @@
   if (!next_payload_known_ || available_bytes_ < next_payload_)
     return false;
   next_payload_known_ = false;
 
   // Extract data from |data_list_| used to form a full protocol buffer.
   DataList buffers;
   std::deque<const uint8*> buffer_pointers;
   std::deque<int> buffer_sizes;
   while (next_payload_ > 0 && !data_list_.empty()) {
     scoped_refptr<media::DataBuffer> buffer = data_list_.front();
-    int read_bytes = std::min(
-        static_cast<int>(buffer->GetDataSize()) - last_read_position_,
-        next_payload_);
+    size_t read_bytes = std::min(buffer->GetDataSize() - last_read_position_,
+                                 next_payload_);
 
     buffers.push_back(buffer);
     buffer_pointers.push_back(buffer->GetData() + last_read_position_);
     buffer_sizes.push_back(read_bytes);
 
     // Adjust counters.
     last_read_position_ += read_bytes;
     next_payload_ -= read_bytes;
     available_bytes_ -= read_bytes;
 
     // If the front buffer is fully read, remove it from the queue.
     if (buffer->GetDataSize() == last_read_position_) {
       data_list_.pop_front();
       last_read_position_ = 0;
     }
   }
-  DCHECK_EQ(0, next_payload_);
+  DCHECK_EQ(0UL, next_payload_);
   DCHECK_EQ(buffers.size(), buffer_pointers.size());
   DCHECK_EQ(buffers.size(), buffer_sizes.size());
 
   // Create a MultipleArrayInputStream for parsing.
   MultipleArrayInputStream stream(buffers.size());
   for (size_t i = 0; i < buffers.size(); ++i) {
     stream.SetBuffer(i, buffer_pointers[i], buffer_sizes[i]);
   }
 
   // And finally it is parsing.
   *message = new T();
   bool ret = (*message)->ParseFromZeroCopyStream(&stream);
   if (!ret)
     delete *message;
   return ret;
 }
 
 bool ProtocolDecoder::GetPayloadSize(int* size) {
   // The header has a size of 4 bytes.
-  const int kHeaderSize = sizeof(int32);
+  const size_t kHeaderSize = sizeof(int32);
 
   if (available_bytes_ < kHeaderSize)
     return false;
 
   std::string header;
   while (header.length() < kHeaderSize && !data_list_.empty()) {
     scoped_refptr<media::DataBuffer> buffer = data_list_.front();
 
     // Find out how many bytes we need and how many bytes are available in this
     // buffer.
@@ skipping 18 matching lines @@
 
   if (header.length() == kHeaderSize) {
     *size = talk_base::GetBE32(header.c_str());
     return true;
   }
   NOTREACHED() << "Unable to extract payload size";
   return false;
 }
 
 }  // namespace remoting