third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/message_lite.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // 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 15 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Authors: wink@google.com (Wink Saville),
 //          kenton@google.com (Kenton Varda)
 //  Based on original Protocol Buffers design by
 //  Sanjay Ghemawat, Jeff Dean, and others.
 
+#include <google/protobuf/arena.h>
+#include <google/protobuf/generated_message_util.h>
 #include <google/protobuf/message_lite.h>
-#include <google/protobuf/arena.h>
 #include <google/protobuf/repeated_field.h>
 #include <string>
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
 #include <google/protobuf/stubs/stl_util.h>
 
 namespace google {
 namespace protobuf {
 
-MessageLite::~MessageLite() {}
-
 string MessageLite::InitializationErrorString() const {
   return "(cannot determine missing fields for lite message)";
 }
 
 namespace {
 
 // When serializing, we first compute the byte size, then serialize the message.
 // If serialization produces a different number of bytes than expected, we
 // call this function, which crashes.  The problem could be due to a bug in the
 // protobuf implementation but is more likely caused by concurrent modification
 // of the message.  This function attempts to distinguish between the two and
 // provide a useful error message.
-void ByteSizeConsistencyError(int byte_size_before_serialization,
-                              int byte_size_after_serialization,
-                              int bytes_produced_by_serialization,
+void ByteSizeConsistencyError(size_t byte_size_before_serialization,
+                              size_t byte_size_after_serialization,
+                              size_t bytes_produced_by_serialization,
                               const MessageLite& message) {
   GOOGLE_CHECK_EQ(byte_size_before_serialization, byte_size_after_serialization)
       << message.GetTypeName()
       << " was modified concurrently during serialization.";
   GOOGLE_CHECK_EQ(bytes_produced_by_serialization, byte_size_before_serialization)
       << "Byte size calculation and serialization were inconsistent.  This "
          "may indicate a bug in protocol buffers or it may be caused by "
          "concurrent modification of " << message.GetTypeName() << ".";
   GOOGLE_LOG(FATAL) << "This shouldn't be called if all the sizes are equal.";
 }
@@ skipping 138 matching lines @@
   return InlineParseFromArray(data, size, this);
 }
 
 bool MessageLite::ParsePartialFromArray(const void* data, int size) {
   return InlineParsePartialFromArray(data, size, this);
 }
 
 
 // ===================================================================
 
-uint8* MessageLite::SerializeWithCachedSizesToArray(uint8* target) const {
+uint8* MessageLite::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, uint8* target) const {
   // We only optimize this when using optimize_for = SPEED.  In other cases
   // we just use the CodedOutputStream path.
   int size = GetCachedSize();
   io::ArrayOutputStream out(target, size);
   io::CodedOutputStream coded_out(&out);
   SerializeWithCachedSizes(&coded_out);
   GOOGLE_CHECK(!coded_out.HadError());
   return target + size;
 }
 
 bool MessageLite::SerializeToCodedStream(io::CodedOutputStream* output) const {
   GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
   return SerializePartialToCodedStream(output);
 }
 
+size_t MessageLite::ByteSizeLong() const {
+  return internal::FromIntSize(ByteSize());
+}
+
 bool MessageLite::SerializePartialToCodedStream(
     io::CodedOutputStream* output) const {
-  const int size = ByteSize();  // Force size to be cached.
-  if (size < 0) {
-    // Messages >2G cannot be serialized due to overflow computing ByteSize.
-    GOOGLE_LOG(ERROR) << "Error computing ByteSize (possible overflow?).";
+  const size_t size = ByteSizeLong();  // Force size to be cached.
+  if (size > INT_MAX) {
+    GOOGLE_LOG(ERROR) << "Exceeded maximum protobuf size of 2GB.";
     return false;
   }
 
   uint8* buffer = output->GetDirectBufferForNBytesAndAdvance(size);
   if (buffer != NULL) {
     uint8* end = SerializeWithCachedSizesToArray(buffer);
     if (end - buffer != size) {
-      ByteSizeConsistencyError(size, ByteSize(), end - buffer, *this);
+      ByteSizeConsistencyError(size, ByteSizeLong(), end - buffer, *this);
     }
     return true;
   } else {
     int original_byte_count = output->ByteCount();
     SerializeWithCachedSizes(output);
     if (output->HadError()) {
       return false;
     }
     int final_byte_count = output->ByteCount();
 
     if (final_byte_count - original_byte_count != size) {
-      ByteSizeConsistencyError(size, ByteSize(),
+      ByteSizeConsistencyError(size, ByteSizeLong(),
                                final_byte_count - original_byte_count, *this);
     }
 
     return true;
   }
 }
 
 bool MessageLite::SerializeToZeroCopyStream(
     io::ZeroCopyOutputStream* output) const {
   io::CodedOutputStream encoder(output);
   return SerializeToCodedStream(&encoder);
 }
 
 bool MessageLite::SerializePartialToZeroCopyStream(
     io::ZeroCopyOutputStream* output) const {
   io::CodedOutputStream encoder(output);
   return SerializePartialToCodedStream(&encoder);
 }
 
 bool MessageLite::AppendToString(string* output) const {
   GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
   return AppendPartialToString(output);
 }
 
 bool MessageLite::AppendPartialToString(string* output) const {
-  int old_size = output->size();
-  int byte_size = ByteSize();
-  if (byte_size < 0) {
-    // Messages >2G cannot be serialized due to overflow computing ByteSize.
-    GOOGLE_LOG(ERROR) << "Error computing ByteSize (possible overflow?).";
+  size_t old_size = output->size();
+  size_t byte_size = ByteSizeLong();
+  if (byte_size > INT_MAX) {
+    GOOGLE_LOG(ERROR) << "Exceeded maximum protobuf size of 2GB.";
     return false;
   }
 
   STLStringResizeUninitialized(output, old_size + byte_size);
   uint8* start =
       reinterpret_cast<uint8*>(io::mutable_string_data(output) + old_size);
   uint8* end = SerializeWithCachedSizesToArray(start);
   if (end - start != byte_size) {
-    ByteSizeConsistencyError(byte_size, ByteSize(), end - start, *this);
+    ByteSizeConsistencyError(byte_size, ByteSizeLong(), end - start, *this);
   }
   return true;
 }
 
 bool MessageLite::SerializeToString(string* output) const {
   output->clear();
   return AppendToString(output);
 }
 
 bool MessageLite::SerializePartialToString(string* output) const {
   output->clear();
   return AppendPartialToString(output);
 }
 
 bool MessageLite::SerializeToArray(void* data, int size) const {
   GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
   return SerializePartialToArray(data, size);
 }
 
 bool MessageLite::SerializePartialToArray(void* data, int size) const {
-  int byte_size = ByteSize();
+  int byte_size = ByteSizeLong();
   if (size < byte_size) return false;
   uint8* start = reinterpret_cast<uint8*>(data);
   uint8* end = SerializeWithCachedSizesToArray(start);
   if (end - start != byte_size) {
-    ByteSizeConsistencyError(byte_size, ByteSize(), end - start, *this);
+    ByteSizeConsistencyError(byte_size, ByteSizeLong(), end - start, *this);
   }
   return true;
 }
 
 string MessageLite::SerializeAsString() const {
   // If the compiler implements the (Named) Return Value Optimization,
   // the local variable 'output' will not actually reside on the stack
   // of this function, but will be overlaid with the object that the
   // caller supplied for the return value to be constructed in.
   string output;
@@ skipping 22 matching lines @@
 }
 template<>
 void GenericTypeHandler<string>::Merge(const string& from,
                                               string* to) {
   *to = from;
 }
 }  // namespace internal
 
 }  // namespace protobuf
 }  // namespace google