Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/src/google/protobuf/message.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 28 matching lines @@
 #include <google/protobuf/message.h>
 
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/mutex.h>
 #include <google/protobuf/stubs/once.h>
 #include <google/protobuf/reflection_internal.h>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 #include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/map_field.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/map_field.h>
 #include <google/protobuf/reflection_ops.h>
 #include <google/protobuf/wire_format.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/map_util.h>
 #include <google/protobuf/stubs/singleton.h>
 #include <google/protobuf/stubs/stl_util.h>
 
 namespace google {
 namespace protobuf {
 
 using internal::WireFormat;
 using internal::ReflectionOps;
 
+Message::~Message() {}
+
 void Message::MergeFrom(const Message& from) {
   const Descriptor* descriptor = GetDescriptor();
   GOOGLE_CHECK_EQ(from.GetDescriptor(), descriptor)
     << ": Tried to merge from a message with a different type.  "
        "to: " << descriptor->full_name() << ", "
        "from: " << from.GetDescriptor()->full_name();
   ReflectionOps::Merge(from, this);
 }
 
 void Message::CheckTypeAndMergeFrom(const MessageLite& other) {
@@ skipping 14 matching lines @@
 }
 
 void Message::Clear() {
   ReflectionOps::Clear(this);
 }
 
 bool Message::IsInitialized() const {
   return ReflectionOps::IsInitialized(*this);
 }
 
-void Message::FindInitializationErrors(std::vector<string>* errors) const {
+void Message::FindInitializationErrors(vector<string>* errors) const {
   return ReflectionOps::FindInitializationErrors(*this, "", errors);
 }
 
 string Message::InitializationErrorString() const {
-  std::vector<string> errors;
+  vector<string> errors;
   FindInitializationErrors(&errors);
   return Join(errors, ", ");
 }
 
 void Message::CheckInitialized() const {
   GOOGLE_CHECK(IsInitialized())
     << "Message of type \"" << GetDescriptor()->full_name()
     << "\" is missing required fields: " << InitializationErrorString();
 }
 
@@ skipping 24 matching lines @@
   io::IstreamInputStream zero_copy_input(input);
   return ParsePartialFromZeroCopyStream(&zero_copy_input) && input->eof();
 }
 
 
 void Message::SerializeWithCachedSizes(
     io::CodedOutputStream* output) const {
   WireFormat::SerializeWithCachedSizes(*this, GetCachedSize(), output);
 }
 
-size_t Message::ByteSizeLong() const {
-  size_t size = WireFormat::ByteSize(*this);
-  SetCachedSize(internal::ToCachedSize(size));
+int Message::ByteSize() const {
+  int size = WireFormat::ByteSize(*this);
+  SetCachedSize(size);
   return size;
 }
 
 void Message::SetCachedSize(int /* size */) const {
   GOOGLE_LOG(FATAL) << "Message class \"" << GetDescriptor()->full_name()
              << "\" implements neither SetCachedSize() nor ByteSize().  "
                 "Must implement one or the other.";
 }
 
 int Message::SpaceUsed() const {
@@ skipping 56 matching lines @@
 
 #undef HANDLE_TYPE
 
 void* Reflection::MutableRawRepeatedString(
     Message* message, const FieldDescriptor* field, bool is_string) const {
   return MutableRawRepeatedField(message, field,
       FieldDescriptor::CPPTYPE_STRING, FieldOptions::STRING, NULL);
 }
 
 
+// Default EnumValue API implementations. Real reflection implementations should
+// override these. However, there are several legacy implementations that do
+// not, and cannot easily be changed at the same time as the Reflection API, so
+// we provide these for now.
+// TODO: Remove these once all Reflection implementations are updated.
+int Reflection::GetEnumValue(const Message& message,
+                             const FieldDescriptor* field) const {
+  GOOGLE_LOG(FATAL) << "Unimplemented EnumValue API.";
+  return 0;
+}
+void Reflection::SetEnumValue(Message* message,
+                  const FieldDescriptor* field,
+                  int value) const {
+  GOOGLE_LOG(FATAL) << "Unimplemented EnumValue API.";
+}
+int Reflection::GetRepeatedEnumValue(
+    const Message& message,
+    const FieldDescriptor* field, int index) const {
+  GOOGLE_LOG(FATAL) << "Unimplemented EnumValue API.";
+  return 0;
+}
+void Reflection::SetRepeatedEnumValue(Message* message,
+                                  const FieldDescriptor* field, int index,
+                                  int value) const {
+  GOOGLE_LOG(FATAL) << "Unimplemented EnumValue API.";
+}
+void Reflection::AddEnumValue(Message* message,
+                  const FieldDescriptor* field,
+                  int value) const {
+  GOOGLE_LOG(FATAL) << "Unimplemented EnumValue API.";
+}
+
 MapIterator Reflection::MapBegin(
     Message* message,
     const FieldDescriptor* field) const {
   GOOGLE_LOG(FATAL) << "Unimplemented Map Reflection API.";
   MapIterator iter(message, field);
   return iter;
 }
 
 MapIterator Reflection::MapEnd(
     Message* message,
@@ skipping 22 matching lines @@
   void RegisterType(const Descriptor* descriptor, const Message* prototype);
 
   // implements MessageFactory ---------------------------------------
   const Message* GetPrototype(const Descriptor* type);
 
  private:
   // Only written at static init time, so does not require locking.
   hash_map<const char*, RegistrationFunc*,
            hash<const char*>, streq> file_map_;
 
+  // Initialized lazily, so requires locking.
   Mutex mutex_;
-  // Initialized lazily, so requires locking.
   hash_map<const Descriptor*, const Message*> type_map_;
 };
 
 GeneratedMessageFactory* generated_message_factory_ = NULL;
 GOOGLE_PROTOBUF_DECLARE_ONCE(generated_message_factory_once_init_);
 
 void ShutdownGeneratedMessageFactory() {
   delete generated_message_factory_;
 }
 
@@ skipping 192 matching lines @@
 GOOGLE_ATTRIBUTE_NOINLINE
 #endif
 void* GenericTypeHandler<Message>::GetMaybeArenaPointer(
     Message* value) {
   return value->GetMaybeArenaPointer();
 }
 }  // namespace internal
 
 }  // namespace protobuf
 }  // namespace google