Update protobuf to r428, part 1.

third_party/protobuf/src/google/protobuf/io/coded_stream.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // http://code.google.com/p/protobuf/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 25 matching lines @@
 // of small values (especially varints) as fast as possible.  In
 // particular, we optimize for the common case that a read or a write
 // will not cross the end of the buffer, since we can avoid a lot
 // of branching in this case.
 
 #include <google/protobuf/io/coded_stream_inl.h>
 #include <algorithm>
 #include <limits.h>
 #include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/stl_util-inl.h>
+#include <google/protobuf/stubs/stl_util.h>
 
 
 namespace google {
 namespace protobuf {
 namespace io {
 
 namespace {
 
 static const int kMaxVarintBytes = 10;
 static const int kMaxVarint32Bytes = 5;
 
 
 inline bool NextNonEmpty(ZeroCopyInputStream* input,
                          const void** data, int* size) {
   bool success;
   do {
     success = input->Next(data, size);
   } while (success && *size == 0);
   return success;
 }
 
 }  // namespace
 
 // CodedInputStream ==================================================
 
+CodedInputStream::~CodedInputStream() {
+  if (input_ != NULL) {
+    BackUpInputToCurrentPosition();
+  }
+
+  if (total_bytes_warning_threshold_ == -2) {
+    GOOGLE_LOG(WARNING) << "The total number of bytes read was " << total_bytes_read_;
+  }
+}
+
+// Static.
+int CodedInputStream::default_recursion_limit_ = 100;
+
 
 void CodedInputStream::BackUpInputToCurrentPosition() {
   int backup_bytes = BufferSize() + buffer_size_after_limit_ + overflow_bytes_;
   if (backup_bytes > 0) {
     input_->BackUp(backup_bytes);
 
     // total_bytes_read_ doesn't include overflow_bytes_.
     total_bytes_read_ -= BufferSize() + buffer_size_after_limit_;
     buffer_end_ = buffer_;
     buffer_size_after_limit_ = 0;
     overflow_bytes_ = 0;
   }
 }
 
 inline void CodedInputStream::RecomputeBufferLimits() {
   buffer_end_ += buffer_size_after_limit_;
   int closest_limit = min(current_limit_, total_bytes_limit_);
   if (closest_limit < total_bytes_read_) {
     // The limit position is in the current buffer.  We must adjust
     // the buffer size accordingly.
     buffer_size_after_limit_ = total_bytes_read_ - closest_limit;
     buffer_end_ -= buffer_size_after_limit_;
   } else {
     buffer_size_after_limit_ = 0;
   }
 }
 
 CodedInputStream::Limit CodedInputStream::PushLimit(int byte_limit) {
   // Current position relative to the beginning of the stream.
-  int current_position = total_bytes_read_ -
-      (BufferSize() + buffer_size_after_limit_);
+  int current_position = CurrentPosition();
 
   Limit old_limit = current_limit_;
 
   // security: byte_limit is possibly evil, so check for negative values
   // and overflow.
   if (byte_limit >= 0 &&
       byte_limit <= INT_MAX - current_position) {
     current_limit_ = current_position + byte_limit;
   } else {
     // Negative or overflow.
@@ skipping 13 matching lines @@
   // The limit passed in is actually the *old* limit, which we returned from
   // PushLimit().
   current_limit_ = limit;
   RecomputeBufferLimits();
 
   // We may no longer be at a legitimate message end.  ReadTag() needs to be
   // called again to find out.
   legitimate_message_end_ = false;
 }
 
-int CodedInputStream::BytesUntilLimit() {
+int CodedInputStream::BytesUntilLimit() const {
   if (current_limit_ == INT_MAX) return -1;
-  int current_position = total_bytes_read_ -
-      (BufferSize() + buffer_size_after_limit_);
+  int current_position = CurrentPosition();
 
   return current_limit_ - current_position;
 }
 
 void CodedInputStream::SetTotalBytesLimit(
     int total_bytes_limit, int warning_threshold) {
   // Make sure the limit isn't already past, since this could confuse other
   // code.
-  int current_position = total_bytes_read_ -
-      (BufferSize() + buffer_size_after_limit_);
+  int current_position = CurrentPosition();
   total_bytes_limit_ = max(current_position, total_bytes_limit);
-  total_bytes_warning_threshold_ = warning_threshold;
+  if (warning_threshold >= 0) {
+    total_bytes_warning_threshold_ = warning_threshold;
+  } else {
+    // warning_threshold is negative
+    total_bytes_warning_threshold_ = -1;
+  }
   RecomputeBufferLimits();
 }
 
 void CodedInputStream::PrintTotalBytesLimitError() {
   GOOGLE_LOG(ERROR) << "A protocol message was rejected because it was too "
                 "big (more than " << total_bytes_limit_
              << " bytes).  To increase the limit (or to disable these "
                 "warnings), see CodedInputStream::SetTotalBytesLimit() "
                 "in google/protobuf/io/coded_stream.h.";
 }
@@ skipping 199 matching lines @@
         legitimate_message_end_ = current_limit_ == total_bytes_limit_;
       } else {
         legitimate_message_end_ = true;
       }
       return 0;
     }
   }
 
   // For the slow path, just do a 64-bit read. Try to optimize for one-byte tags
   // again, since we have now refreshed the buffer.
-  uint64 result;
+  uint64 result = 0;
   if (!ReadVarint64(&result)) return 0;
   return static_cast<uint32>(result);
 }
 
 uint32 CodedInputStream::ReadTagFallback() {
-  if (BufferSize() >= kMaxVarintBytes ||
+  const int buf_size = BufferSize();
+  if (buf_size >= kMaxVarintBytes ||
       // Optimization:  If the varint ends at exactly the end of the buffer,
       // we can detect that and still use the fast path.
-      (buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
+      (buf_size > 0 && !(buffer_end_[-1] & 0x80))) {
     uint32 tag;
     const uint8* end = ReadVarint32FromArray(buffer_, &tag);
     if (end == NULL) {
       return 0;
     }
     buffer_ = end;
     return tag;
   } else {
     // We are commonly at a limit when attempting to read tags. Try to quickly
     // detect this case without making another function call.
-    if (buffer_ == buffer_end_ && buffer_size_after_limit_ > 0 &&
+    if ((buf_size == 0) &&
+        ((buffer_size_after_limit_ > 0) ||
+         (total_bytes_read_ == current_limit_)) &&
         // Make sure that the limit we hit is not total_bytes_limit_, since
         // in that case we still need to call Refresh() so that it prints an
         // error.
         total_bytes_read_ - buffer_size_after_limit_ < total_bytes_limit_) {
       // We hit a byte limit.
       legitimate_message_end_ = true;
       return 0;
     }
     return ReadTagSlow();
   }
@@ skipping 83 matching lines @@
   if (total_bytes_warning_threshold_ >= 0 &&
       total_bytes_read_ >= total_bytes_warning_threshold_) {
       GOOGLE_LOG(WARNING) << "Reading dangerously large protocol message.  If the "
                       "message turns out to be larger than "
                    << total_bytes_limit_ << " bytes, parsing will be halted "
                       "for security reasons.  To increase the limit (or to "
                       "disable these warnings), see "
                       "CodedInputStream::SetTotalBytesLimit() in "
                       "google/protobuf/io/coded_stream.h.";
 
-    // Don't warn again for this stream.
-    total_bytes_warning_threshold_ = -1;
+    // Don't warn again for this stream, and print total size at the end.
+    total_bytes_warning_threshold_ = -2;
   }
 
   const void* void_buffer;
   int buffer_size;
   if (NextNonEmpty(input_, &void_buffer, &buffer_size)) {
     buffer_ = reinterpret_cast<const uint8*>(void_buffer);
     buffer_end_ = buffer_ + buffer_size;
     GOOGLE_CHECK_GE(buffer_size, 0);
 
     if (total_bytes_read_ <= INT_MAX - buffer_size) {
@@ skipping 323 matching lines @@
       return 9;
     } else {
       return 10;
     }
   }
 }
 
 }  // namespace io
 }  // namespace protobuf
 }  // namespace google