Update protobuf to r428, part 1.

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

 // 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 152 matching lines @@
   // this constructor.
   explicit CodedInputStream(const uint8* buffer, int size);
 
   // Destroy the CodedInputStream and position the underlying
   // ZeroCopyInputStream at the first unread byte.  If an error occurred while
   // reading (causing a method to return false), then the exact position of
   // the input stream may be anywhere between the last value that was read
   // successfully and the stream's byte limit.
   ~CodedInputStream();
 
+  // Return true if this CodedInputStream reads from a flat array instead of
+  // a ZeroCopyInputStream.
+  inline bool IsFlat() const;
 
   // Skips a number of bytes.  Returns false if an underlying read error
   // occurs.
   bool Skip(int count);
 
   // Sets *data to point directly at the unread part of the CodedInputStream's
   // underlying buffer, and *size to the size of that buffer, but does not
   // advance the stream's current position.  This will always either produce
   // a non-empty buffer or return false.  If the caller consumes any of
   // this data, it should then call Skip() to skip over the consumed bytes.
@@ skipping 121 matching lines @@
   // The value returned by PushLimit() is opaque to the caller, and must
   // be passed unchanged to the corresponding call to PopLimit().
   Limit PushLimit(int byte_limit);
 
   // Pops the last limit pushed by PushLimit().  The input must be the value
   // returned by that call to PushLimit().
   void PopLimit(Limit limit);
 
   // Returns the number of bytes left until the nearest limit on the
   // stack is hit, or -1 if no limits are in place.
-  int BytesUntilLimit();
+  int BytesUntilLimit() const;
+
+  // Returns current position relative to the beginning of the input stream.
+  int CurrentPosition() const;
 
   // Total Bytes Limit -----------------------------------------------
   // To prevent malicious users from sending excessively large messages
   // and causing integer overflows or memory exhaustion, CodedInputStream
   // imposes a hard limit on the total number of bytes it will read.
 
   // Sets the maximum number of bytes that this CodedInputStream will read
   // before refusing to continue.  To prevent integer overflows in the
   // protocol buffers implementation, as well as to prevent servers from
   // allocating enormous amounts of memory to hold parsed messages, the
   // maximum message length should be limited to the shortest length that
   // will not harm usability.  The theoretical shortest message that could
   // cause integer overflows is 512MB.  The default limit is 64MB.  Apps
   // should set shorter limits if possible.  If warning_threshold is not -1,
   // a warning will be printed to stderr after warning_threshold bytes are
-  // read.  An error will always be printed to stderr if the limit is
-  // reached.
+  // read.  For backwards compatibility all negative values get squached to -1,
+  // as other negative values might have special internal meanings.
+  // An error will always be printed to stderr if the limit is reached.
   //
   // This is unrelated to PushLimit()/PopLimit().
   //
   // Hint:  If you are reading this because your program is printing a
   //   warning about dangerously large protocol messages, you may be
   //   confused about what to do next.  The best option is to change your
   //   design such that excessively large messages are not necessary.
   //   For example, try to design file formats to consist of many small
   //   messages rather than a single large one.  If this is infeasible,
   //   you will need to increase the limit.  Chances are, though, that
   //   your code never constructs a CodedInputStream on which the limit
   //   can be set.  You probably parse messages by calling things like
   //   Message::ParseFromString().  In this case, you will need to change
   //   your code to instead construct some sort of ZeroCopyInputStream
   //   (e.g. an ArrayInputStream), construct a CodedInputStream around
   //   that, then call Message::ParseFromCodedStream() instead.  Then
   //   you can adjust the limit.  Yes, it's more work, but you're doing
   //   something unusual.
   void SetTotalBytesLimit(int total_bytes_limit, int warning_threshold);
 
   // Recursion Limit -------------------------------------------------
   // To prevent corrupt or malicious messages from causing stack overflows,
   // we must keep track of the depth of recursion when parsing embedded
   // messages and groups.  CodedInputStream keeps track of this because it
   // is the only object that is passed down the stack during parsing.
 
-  // Sets the maximum recursion depth.  The default is 64.
+  // Sets the maximum recursion depth.  The default is 100.
   void SetRecursionLimit(int limit);
 
+
   // Increments the current recursion depth.  Returns true if the depth is
   // under the limit, false if it has gone over.
   bool IncrementRecursionDepth();
 
   // Decrements the recursion depth.
   void DecrementRecursionDepth();
 
   // Extension Registry ----------------------------------------------
   // ADVANCED USAGE:  99.9% of people can ignore this section.
   //
@@ skipping 55 matching lines @@
   // if these objects are represented using DynamicMessage.
   //
   // Using DynamicMessageFactory on which you have called
   // SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the
   // above requirement.
   //
   // If either pool or factory is NULL, both must be NULL.
   //
   // Note that this feature is ignored when parsing "lite" messages as they do
   // not have descriptors.
-  void SetExtensionRegistry(DescriptorPool* pool, MessageFactory* factory);
+  void SetExtensionRegistry(const DescriptorPool* pool,
+                            MessageFactory* factory);
 
   // Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool
   // has been provided.
   const DescriptorPool* GetExtensionPool();
 
   // Get the MessageFactory set via SetExtensionRegistry(), or NULL if no
   // factory has been provided.
   MessageFactory* GetExtensionFactory();
 
  private:
@@ skipping 28 matching lines @@
   // only tracks the number of bytes before that limit.  This field
   // contains the number of bytes after it.  Note that this implies that if
   // buffer_size_ == 0 and buffer_size_after_limit_ > 0, we know we've
   // hit a limit.  However, if both are zero, it doesn't necessarily mean
   // we aren't at a limit -- the buffer may have ended exactly at the limit.
   int buffer_size_after_limit_;
 
   // Maximum number of bytes to read, period.  This is unrelated to
   // current_limit_.  Set using SetTotalBytesLimit().
   int total_bytes_limit_;
+
+  // If positive/0: Limit for bytes read after which a warning due to size
+  // should be logged.
+  // If -1: Printing of warning disabled. Can be set by client.
+  // If -2: Internal: Limit has been reached, print full size when destructing.
   int total_bytes_warning_threshold_;
 
   // Current recursion depth, controlled by IncrementRecursionDepth() and
   // DecrementRecursionDepth().
   int recursion_depth_;
   // Recursion depth limit, set by SetRecursionLimit().
   int recursion_limit_;
 
   // See SetExtensionRegistry().
   const DescriptorPool* extension_pool_;
@@ skipping 37 matching lines @@
   uint32 ReadTagFallback();
   uint32 ReadTagSlow();
   bool ReadStringFallback(string* buffer, int size);
 
   // Return the size of the buffer.
   int BufferSize() const;
 
   static const int kDefaultTotalBytesLimit = 64 << 20;  // 64MB
 
   static const int kDefaultTotalBytesWarningThreshold = 32 << 20;  // 32MB
-  static const int kDefaultRecursionLimit = 64;
+
+  static int default_recursion_limit_;  // 100 by default.
 };
 
 // Class which encodes and writes binary data which is composed of varint-
 // encoded integers and fixed-width pieces.  Wraps a ZeroCopyOutputStream.
 // Most users will not need to deal with CodedOutputStream.
 //
 // Most methods of CodedOutputStream which return a bool return false if an
 // underlying I/O error occurs.  Once such a failure occurs, the
 // CodedOutputStream is broken and is no longer useful. The Write* methods do
 // not return the stream status, but will invalidate the stream if an error
@@ skipping 331 matching lines @@
 inline void CodedInputStream::GetDirectBufferPointerInline(const void** data,
                                                            int* size) {
   *data = buffer_;
   *size = buffer_end_ - buffer_;
 }
 
 inline bool CodedInputStream::ExpectAtEnd() {
   // If we are at a limit we know no more bytes can be read.  Otherwise, it's
   // hard to say without calling Refresh(), and we'd rather not do that.
 
-  if (buffer_ == buffer_end_ && buffer_size_after_limit_ != 0) {
+  if (buffer_ == buffer_end_ &&
+      ((buffer_size_after_limit_ != 0) ||
+       (total_bytes_read_ == current_limit_))) {
     last_tag_ = 0;                   // Pretend we called ReadTag()...
     legitimate_message_end_ = true;  // ... and it hit EOF.
     return true;
   } else {
     return false;
   }
 }
 
+inline int CodedInputStream::CurrentPosition() const {
+  return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
+}
+
 inline uint8* CodedOutputStream::GetDirectBufferForNBytesAndAdvance(int size) {
   if (buffer_size_ < size) {
     return NULL;
   } else {
     uint8* result = buffer_;
     Advance(size);
     return result;
   }
 }
 
@@ skipping 119 matching lines @@
 
 inline bool CodedInputStream::IncrementRecursionDepth() {
   ++recursion_depth_;
   return recursion_depth_ <= recursion_limit_;
 }
 
 inline void CodedInputStream::DecrementRecursionDepth() {
   if (recursion_depth_ > 0) --recursion_depth_;
 }
 
-inline void CodedInputStream::SetExtensionRegistry(DescriptorPool* pool,
+inline void CodedInputStream::SetExtensionRegistry(const DescriptorPool* pool,
                                                    MessageFactory* factory) {
   extension_pool_ = pool;
   extension_factory_ = factory;
 }
 
 inline const DescriptorPool* CodedInputStream::GetExtensionPool() {
   return extension_pool_;
 }
 
 inline MessageFactory* CodedInputStream::GetExtensionFactory() {
@@ skipping 11 matching lines @@
     total_bytes_read_(0),
     overflow_bytes_(0),
     last_tag_(0),
     legitimate_message_end_(false),
     aliasing_enabled_(false),
     current_limit_(kint32max),
     buffer_size_after_limit_(0),
     total_bytes_limit_(kDefaultTotalBytesLimit),
     total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
     recursion_depth_(0),
-    recursion_limit_(kDefaultRecursionLimit),
+    recursion_limit_(default_recursion_limit_),
     extension_pool_(NULL),
     extension_factory_(NULL) {
   // Eagerly Refresh() so buffer space is immediately available.
   Refresh();
 }
 
 inline CodedInputStream::CodedInputStream(const uint8* buffer, int size)
   : input_(NULL),
     buffer_(buffer),
     buffer_end_(buffer + size),
     total_bytes_read_(size),
     overflow_bytes_(0),
     last_tag_(0),
     legitimate_message_end_(false),
     aliasing_enabled_(false),
     current_limit_(size),
     buffer_size_after_limit_(0),
     total_bytes_limit_(kDefaultTotalBytesLimit),
     total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
     recursion_depth_(0),
-    recursion_limit_(kDefaultRecursionLimit),
+    recursion_limit_(default_recursion_limit_),
     extension_pool_(NULL),
     extension_factory_(NULL) {
   // Note that setting current_limit_ == size is important to prevent some
   // code paths from trying to access input_ and segfaulting.
 }
 
-inline CodedInputStream::~CodedInputStream() {
-  if (input_ != NULL) {
-    BackUpInputToCurrentPosition();
-  }
+inline bool CodedInputStream::IsFlat() const {
+  return input_ == NULL;
 }
 
 }  // namespace io
 }  // namespace protobuf
 
 
 #if defined(_MSC_VER) && _MSC_VER >= 1300
   #pragma runtime_checks("c", restore)
 #endif  // _MSC_VER
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_IO_CODED_STREAM_H__