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

third_party/protobuf/src/google/protobuf/generated_message_util.h

 // 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 23 matching lines @@
 //
 // This file contains miscellaneous helper code used by generated code --
 // including lite types -- but which should not be used directly by users.
 
 #ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
 #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
 
 #include <assert.h>
 #include <string>
 
+#include <google/protobuf/stubs/once.h>
 #include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/once.h>
-#include <google/protobuf/has_bits.h>
-
-#ifndef PROTOBUF_FINAL
-#if __cplusplus >= 201103L
-#define PROTOBUF_FINAL final
-#else
-#define PROTOBUF_FINAL
-#endif
-#endif  // !PROTOBUF_FINAL
 
 namespace google {
 
 namespace protobuf {
 
 class Arena;
 namespace io { class CodedInputStream; }
 
 namespace internal {
 
 
 // Annotation for the compiler to emit a deprecation message if a field marked
 // with option 'deprecated=true' is used in the code, or for other things in
 // generated code which are deprecated.
 //
 // For internal use in the pb.cc files, deprecation warnings are suppressed
 // there.
 #undef DEPRECATED_PROTOBUF_FIELD
 #define PROTOBUF_DEPRECATED
 
-#define GOOGLE_PROTOBUF_DEPRECATED_ATTR
+#define PROTOBUF_DEPRECATED_ATTR
 
 
 // Constants for special floating point values.
 LIBPROTOBUF_EXPORT double Infinity();
 LIBPROTOBUF_EXPORT double NaN();
 
-// This type is used to define a global variable, without it's constructor
-// and destructor run on start and end of the program lifetime. This circumvents
-// the initial construction order fiasco, while keeping the address of the
-// empty string a compile time constant.
-template <typename T>
-class ExplicitlyConstructed {
- public:
-  void DefaultConstruct() {
-    new (&union_) T();
-    init_ = true;
-  }
-
-  bool IsInitialized() { return init_; }
-  void Shutdown() {
-    if (init_) {
-      init_ = false;
-      get_mutable()->~T();
-    }
-  }
-
-#if __cplusplus >= 201103L
-  constexpr
-#endif
-      const T&
-      get() const {
-    return reinterpret_cast<const T&>(union_);
-  }
-  T* get_mutable() { return reinterpret_cast<T*>(&union_); }
-
- private:
-  // Prefer c++14 aligned_storage, but for compatibility this will do.
-  union AlignedUnion {
-    char space[sizeof(T)];
-    int64 align_to_int64;
-    void* align_to_ptr;
-  } union_;
-  bool init_;  // false by linker
-};
-
 // TODO(jieluo): Change to template. We have tried to use template,
 // but it causes net/rpc/python:rpcutil_test fail (the empty string will
 // init twice). It may related to swig. Change to template after we
 // found the solution.
 
-// Default empty string object. Don't use this directly. Instead, call
+// Default empty string object. Don't use the pointer directly. Instead, call
 // GetEmptyString() to get the reference.
-LIBPROTOBUF_EXPORT extern ExplicitlyConstructed< ::std::string> fixed_address_empty_string;
+LIBPROTOBUF_EXPORT extern const ::std::string* empty_string_;
 LIBPROTOBUF_EXPORT extern ProtobufOnceType empty_string_once_init_;
 LIBPROTOBUF_EXPORT void InitEmptyString();
 
 
 LIBPROTOBUF_EXPORT inline const ::std::string& GetEmptyStringAlreadyInited() {
-  return fixed_address_empty_string.get();
+  assert(empty_string_ != NULL);
+  return *empty_string_;
 }
 
-
 LIBPROTOBUF_EXPORT const ::std::string& GetEmptyString();
 
 LIBPROTOBUF_EXPORT int StringSpaceUsedExcludingSelf(const string& str);
 
 
 // True if IsInitialized() is true for all elements of t.  Type is expected
 // to be a RepeatedPtrField<some message type>.  It's useful to have this
 // helper here to keep the protobuf compiler from ever having to emit loops in
 // IsInitialized() methods.  We want the C++ compiler to inline this or not
 // as it sees fit.
 template <class Type> bool AllAreInitialized(const Type& t) {
   for (int i = t.size(); --i >= 0; ) {
     if (!t.Get(i).IsInitialized()) return false;
   }
   return true;
 }
 
-LIBPROTOBUF_EXPORT void InitProtobufDefaults();
+class ArenaString;
 
-// We compute sizes as size_t but cache them as int.  This function converts a
-// computed size to a cached size.  Since we don't proceed with serialization if
-// the total size was > INT_MAX, it is not important what this function returns
-// for inputs > INT_MAX.
-inline int ToCachedSize(size_t size) {
-  return static_cast<int>(size);
-}
-
-// We mainly calculate sizes in terms of size_t, but some functions that compute
-// sizes return "int".  These int sizes are expected to always be positive.
-// This function is more efficient than casting an int to size_t directly on
-// 64-bit platforms because it avoids making the compiler emit a sign extending
-// instruction, which we don't want and don't want to pay for.
-inline size_t FromIntSize(int size) {
-  // Convert to unsigned before widening so sign extension is not necessary.
-  return static_cast<unsigned int>(size);
-}
+// Read a length (varint32), followed by a string, from *input.  Return a
+// pointer to a copy of the string that resides in *arena.  Requires both
+// args to be non-NULL.  If something goes wrong while reading the data
+// then NULL is returned (e.g., input does not start with a valid varint).
+ArenaString* ReadArenaString(::google::protobuf::io::CodedInputStream* input,
+                             ::google::protobuf::Arena* arena);
 
 }  // namespace internal
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__