third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/arena.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 10 matching lines @@
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // 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.
 
+// This file defines an Arena allocator for better allocation performance.
+
 #ifndef GOOGLE_PROTOBUF_ARENA_H__
 #define GOOGLE_PROTOBUF_ARENA_H__
 
 #include <limits>
 #ifdef max
 #undef max  // Visual Studio defines this macro
 #endif
 #if __cplusplus >= 201103L
 #include <google/protobuf/stubs/type_traits.h>
 #endif
@@ skipping 29 matching lines @@
 template<typename Type>
 class GenericTypeHandler; // repeated_field.h
 
 // Templated cleanup methods.
 template<typename T> void arena_destruct_object(void* object) {
   reinterpret_cast<T*>(object)->~T();
 }
 template<typename T> void arena_delete_object(void* object) {
   delete reinterpret_cast<T*>(object);
 }
-inline void arena_free(void* object, size_t /* size */) {
-  free(object);
+inline void arena_free(void* object, size_t size) {
+#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
+  ::operator delete(object, size);
+#else
+  (void)size;
+  ::operator delete(object);
+#endif
 }
 
 }  // namespace internal
 
 // ArenaOptions provides optional additional parameters to arena construction
 // that control its block-allocation behavior.
 struct ArenaOptions {
   // This defines the size of the first block requested from the system malloc.
   // Subsequent block sizes will increase in a geometric series up to a maximum.
   size_t start_block_size;
@@ skipping 43 matching lines @@
   // intentionally want to avoid monitoring an allocation. (i.e. internal
   // allocations for managing the arena)
   void (*on_arena_allocation)(const std::type_info* allocated_type,
       uint64 alloc_size, void* cookie);
 
   ArenaOptions()
       : start_block_size(kDefaultStartBlockSize),
         max_block_size(kDefaultMaxBlockSize),
         initial_block(NULL),
         initial_block_size(0),
-        block_alloc(&malloc),
+        block_alloc(&::operator new),
         block_dealloc(&internal::arena_free),
         on_arena_init(NULL),
         on_arena_reset(NULL),
         on_arena_destruction(NULL),
         on_arena_allocation(NULL) {}
 
  private:
   // Constants define default starting block size and max block size for
   // arena allocator behavior -- see descriptions above.
   static const size_t kDefaultStartBlockSize = 256;
@@ skipping 48 matching lines @@
 //   present on the type, then its destructor is always called when the
 //   containing arena is destroyed.
 //
 // - One- and two-user-argument forms of CreateMessage<T>() also exist that
 //   forward these constructor arguments to T's constructor: for example,
 //   CreateMessage<T>(Arena*, arg1, arg2) forwards to a constructor T(Arena*,
 //   arg1, arg2).
 //
 // This protocol is implemented by all arena-enabled proto2 message classes as
 // well as RepeatedPtrField.
-
-#if __cplusplus >= 201103L
-class LIBPROTOBUF_EXPORT Arena final {
-#else
+//
+// Do NOT subclass Arena. This class will be marked as final when C++11 is
+// enabled.
 class LIBPROTOBUF_EXPORT Arena {
-#endif
  public:
   // Arena constructor taking custom options. See ArenaOptions below for
   // descriptions of the options available.
   explicit Arena(const ArenaOptions& options) : options_(options) {
     Init();
   }
 
   // Default constructor with sensible default options, tuned for average
   // use-cases.
   Arena() {
@@ skipping 217 matching lines @@
   // Returns the total space used by the arena, which is the sums of the sizes
   // of the underlying blocks. The total space used may not include the new
   // blocks that are allocated by this arena from other threads concurrently
   // with the call to this method.
   GOOGLE_ATTRIBUTE_NOINLINE uint64 SpaceAllocated() const;
   // As above, but does not include any free space in underlying blocks.
   GOOGLE_ATTRIBUTE_NOINLINE uint64 SpaceUsed() const;
 
   // Combines SpaceAllocated and SpaceUsed. Returns a pair of
   // <space_allocated, space_used>.
-  GOOGLE_ATTRIBUTE_NOINLINE pair<uint64, uint64> SpaceAllocatedAndUsed() const;
+  GOOGLE_ATTRIBUTE_NOINLINE std::pair<uint64, uint64> SpaceAllocatedAndUsed() const;
 
   // Frees all storage allocated by this arena after calling destructors
   // registered with OwnDestructor() and freeing objects registered with Own().
   // Any objects allocated on this arena are unusable after this call. It also
   // returns the total space used by the arena which is the sums of the sizes
   // of the allocated blocks. This method is not thread-safe.
   GOOGLE_ATTRIBUTE_NOINLINE uint64 Reset();
 
   // Adds |object| to a list of heap-allocated objects to be freed with |delete|
   // when the arena is destroyed or reset.
@@ skipping 133 matching lines @@
   // This is inside Arena because only Arena has the friend relationships
   // necessary to see the underlying generated code traits.
   template<typename T>
   struct is_destructor_skippable
       : public google::protobuf::internal::integral_constant<
             bool,
             sizeof(InternalIsDestructorSkippableHelper::DestructorSkippable<
                    const T>(static_cast<const T*>(0))) == sizeof(char) ||
                 google::protobuf::internal::has_trivial_destructor<T>::value> {};
 
+ private:
   // CreateMessage<T> requires that T supports arenas, but this private method
   // works whether or not T supports arenas. These are not exposed to user code
   // as it can cause confusing API usages, and end up having double free in
   // user code. These are used only internally from LazyField and Repeated
   // fields, since they are designed to work in all mode combinations.
   template<typename Msg> GOOGLE_ATTRIBUTE_ALWAYS_INLINE
   static Msg* CreateMaybeMessage(
       Arena* arena, typename Msg::InternalArenaConstructable_*) {
     return CreateMessage<Msg>(arena);
   }
@@ skipping 173 matching lines @@
   }
 
   template <typename T>
   static void CreateInArenaStorageInternal(
       T* ptr, Arena* arena, google::protobuf::internal::true_type) {
     new (ptr) T(arena);
   }
   template <typename T>
   static void CreateInArenaStorageInternal(
       T* ptr, Arena* arena, google::protobuf::internal::false_type) {
-    new (ptr) T;
+    new (ptr) T();
   }
 
   template <typename T>
   static void RegisterDestructorInternal(
       T* ptr, Arena* arena, google::protobuf::internal::true_type) {}
   template <typename T>
   static void RegisterDestructorInternal(
       T* ptr, Arena* arena, google::protobuf::internal::false_type) {
     arena->OwnDestructor(ptr);
   }
@@ skipping 101 matching lines @@
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Arena);
 };
 
 // Defined above for supporting environments without RTTI.
 #undef RTTI_TYPE_ID
 
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_ARENA_H__