summaryrefslogtreecommitdiffstats
path: root/toolkit/components/protobuf/m-c-changes.patch
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /toolkit/components/protobuf/m-c-changes.patch
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'toolkit/components/protobuf/m-c-changes.patch')
-rw-r--r--toolkit/components/protobuf/m-c-changes.patch410
1 files changed, 410 insertions, 0 deletions
diff --git a/toolkit/components/protobuf/m-c-changes.patch b/toolkit/components/protobuf/m-c-changes.patch
new file mode 100644
index 000000000..d09e7c5a8
--- /dev/null
+++ b/toolkit/components/protobuf/m-c-changes.patch
@@ -0,0 +1,410 @@
+--- a/toolkit/components/protobuf/src/google/protobuf/wire_format_lite.h
++++ b/toolkit/components/protobuf/src/google/protobuf/wire_format_lite.h
+@@ -35,16 +35,17 @@
+ // Sanjay Ghemawat, Jeff Dean, and others.
+ //
+ // This header is logically internal, but is made public because it is used
+ // from protocol-compiler-generated code, which may reside in other components.
+
+ #ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
+ #define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
+
++#include <algorithm>
+ #include <string>
+ #include <google/protobuf/stubs/common.h>
+ #include <google/protobuf/message_lite.h>
+ #include <google/protobuf/io/coded_stream.h> // for CodedOutputStream::Varint32Size
+
+ namespace google {
+
+ namespace protobuf {
+--- a/toolkit/components/protobuf/src/google/protobuf/wire_format.cc
++++ b/toolkit/components/protobuf/src/google/protobuf/wire_format.cc
+@@ -819,30 +819,35 @@ void WireFormat::SerializeFieldWithCachedSizes(
+ HANDLE_PRIMITIVE_TYPE(SFIXED64, int64, SFixed64, Int64)
+
+ HANDLE_PRIMITIVE_TYPE(FLOAT , float , Float , Float )
+ HANDLE_PRIMITIVE_TYPE(DOUBLE, double, Double, Double)
+
+ HANDLE_PRIMITIVE_TYPE(BOOL, bool, Bool, Bool)
+ #undef HANDLE_PRIMITIVE_TYPE
+
+-#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
+- case FieldDescriptor::TYPE_##TYPE: \
+- WireFormatLite::Write##TYPE_METHOD( \
+- field->number(), \
+- field->is_repeated() ? \
+- message_reflection->GetRepeated##CPPTYPE_METHOD( \
+- message, field, j) : \
+- message_reflection->Get##CPPTYPE_METHOD(message, field), \
+- output); \
++ case FieldDescriptor::TYPE_GROUP:
++ WireFormatLite::WriteGroup(
++ field->number(),
++ field->is_repeated() ?
++ message_reflection->GetRepeatedMessage(
++ message, field, j) :
++ message_reflection->GetMessage(message, field),
++ output);
+ break;
+
+- HANDLE_TYPE(GROUP , Group , Message)
+- HANDLE_TYPE(MESSAGE, Message, Message)
+-#undef HANDLE_TYPE
++ case FieldDescriptor::TYPE_MESSAGE:
++ WireFormatLite::WriteMessage(
++ field->number(),
++ field->is_repeated() ?
++ message_reflection->GetRepeatedMessage(
++ message, field, j) :
++ message_reflection->GetMessage(message, field),
++ output);
++ break;
+
+ case FieldDescriptor::TYPE_ENUM: {
+ const EnumValueDescriptor* value = field->is_repeated() ?
+ message_reflection->GetRepeatedEnum(message, field, j) :
+ message_reflection->GetEnum(message, field);
+ if (is_packed) {
+ WireFormatLite::WriteEnumNoTag(value->number(), output);
+ } else {
+--- b/toolkit/components/protobuf/src/google/protobuf/io/gzip_stream.cc
++++ a/toolkit/components/protobuf/src/google/protobuf/io/gzip_stream.cc
+@@ -28,17 +28,16 @@
+ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ // Author: brianolson@google.com (Brian Olson)
+ //
+ // This file contains the implementation of classes GzipInputStream and
+ // GzipOutputStream.
+
+-#include "config.h"
+
+ #if HAVE_ZLIB
+ #include <google/protobuf/io/gzip_stream.h>
+
+ #include <google/protobuf/stubs/common.h>
+
+ namespace google {
+ namespace protobuf {
+--- b/toolkit/components/protobuf/src/google/protobuf/stubs/common.cc
++++ a/toolkit/components/protobuf/src/google/protobuf/stubs/common.cc
+@@ -31,23 +31,22 @@
+ // Author: kenton@google.com (Kenton Varda)
+
+ #include <google/protobuf/stubs/common.h>
+ #include <google/protobuf/stubs/once.h>
+ #include <stdio.h>
+ #include <errno.h>
+ #include <vector>
+
+-#include "config.h"
+
+ #ifdef _WIN32
+ #define WIN32_LEAN_AND_MEAN // We only need minimal includes
+ #include <windows.h>
+ #define snprintf _snprintf // see comment in strutil.cc
++#elif defined(HAVE_PTHREAD_H)
+-#elif defined(HAVE_PTHREAD)
+ #include <pthread.h>
+ #else
+ #error "No suitable threading library available."
+ #endif
+
+ namespace google {
+ namespace protobuf {
+
+--- b/toolkit/components/protobuf/src/google/protobuf/stubs/common.h
++++ a/toolkit/components/protobuf/src/google/protobuf/stubs/common.h
+@@ -363,71 +363,20 @@
+ // or to make sure a struct is smaller than a certain size:
+ //
+ // COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
+ //
+ // The second argument to the macro is the name of the variable. If
+ // the expression is false, most compilers will issue a warning/error
+ // containing the name of the variable.
+
++#define GOOGLE_COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
+-namespace internal {
+-
+-template <bool>
+-struct CompileAssert {
+-};
+-
+-} // namespace internal
+
+-#undef GOOGLE_COMPILE_ASSERT
+-#define GOOGLE_COMPILE_ASSERT(expr, msg) \
+- typedef ::google::protobuf::internal::CompileAssert<(bool(expr))> \
+- msg[bool(expr) ? 1 : -1]
+
+
+-// Implementation details of COMPILE_ASSERT:
+-//
+-// - COMPILE_ASSERT works by defining an array type that has -1
+-// elements (and thus is invalid) when the expression is false.
+-//
+-// - The simpler definition
+-//
+-// #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
+-//
+-// does not work, as gcc supports variable-length arrays whose sizes
+-// are determined at run-time (this is gcc's extension and not part
+-// of the C++ standard). As a result, gcc fails to reject the
+-// following code with the simple definition:
+-//
+-// int foo;
+-// COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
+-// // not a compile-time constant.
+-//
+-// - By using the type CompileAssert<(bool(expr))>, we ensures that
+-// expr is a compile-time constant. (Template arguments must be
+-// determined at compile-time.)
+-//
+-// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
+-// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written
+-//
+-// CompileAssert<bool(expr)>
+-//
+-// instead, these compilers will refuse to compile
+-//
+-// COMPILE_ASSERT(5 > 0, some_message);
+-//
+-// (They seem to think the ">" in "5 > 0" marks the end of the
+-// template argument list.)
+-//
+-// - The array size is (bool(expr) ? 1 : -1), instead of simply
+-//
+-// ((expr) ? 1 : -1).
+-//
+-// This is to avoid running into a bug in MS VC 7.1, which
+-// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+-
+ // ===================================================================
+ // from google3/base/scoped_ptr.h
+
+ namespace internal {
+
+ // This is an implementation designed to match the anticipated future TR2
+ // implementation of the scoped_ptr class, and its closely-related brethren,
+ // scoped_array, scoped_ptr_malloc, and make_scoped_ptr.
+@@ -582,16 +582,27 @@ enum LogLevel {
+ // in the code which calls the library, especially when
+ // compiled in debug mode.
+
+ #ifdef NDEBUG
+ LOGLEVEL_DFATAL = LOGLEVEL_ERROR
+ #else
+ LOGLEVEL_DFATAL = LOGLEVEL_FATAL
+ #endif
++
++#ifdef ERROR
++ // ERROR is defined as 0 on some windows builds, so `GOOGLE_LOG(ERROR, ...)`
++ // expands into `GOOGLE_LOG(0, ...)` which then expands into
++ // `someGoogleLogging(LOGLEVEL_0, ...)`. This is not ideal, because the
++ // GOOGLE_LOG macro expects to expand itself into
++ // `someGoogleLogging(LOGLEVEL_ERROR, ...)` instead. The workaround to get
++ // everything building is to simply define LOGLEVEL_0 as LOGLEVEL_ERROR and
++ // move on with our lives.
++ , LOGLEVEL_0 = LOGLEVEL_ERROR
++#endif
+ };
+
+ namespace internal {
+
+ class LogFinisher;
+
+ class LIBPROTOBUF_EXPORT LogMessage {
+ public:
+--- b/toolkit/components/protobuf/src/google/protobuf/stubs/hash.h
++++ a/toolkit/components/protobuf/src/google/protobuf/stubs/hash.h
+@@ -32,17 +32,16 @@
+ //
+ // Deals with the fact that hash_map is not defined everywhere.
+
+ #ifndef GOOGLE_PROTOBUF_STUBS_HASH_H__
+ #define GOOGLE_PROTOBUF_STUBS_HASH_H__
+
+ #include <string.h>
+ #include <google/protobuf/stubs/common.h>
+-#include "config.h"
+
+ #if defined(HAVE_HASH_MAP) && defined(HAVE_HASH_SET)
+ #include HASH_MAP_H
+ #include HASH_SET_H
+ #else
+ #define MISSING_HASH
+ #include <map>
+ #include <set>
+--- b/toolkit/components/protobuf/src/google/protobuf/stubs/stringprintf.cc
++++ a/toolkit/components/protobuf/src/google/protobuf/stubs/stringprintf.cc
+@@ -32,17 +32,16 @@
+
+ #include <google/protobuf/stubs/stringprintf.h>
+
+ #include <errno.h>
+ #include <stdarg.h> // For va_list and related operations
+ #include <stdio.h> // MSVC requires this for _vsnprintf
+ #include <vector>
+ #include <google/protobuf/stubs/common.h>
+-#include <google/protobuf/testing/googletest.h>
+
+ namespace google {
+ namespace protobuf {
+
+ #ifdef _MSC_VER
+ enum { IS_COMPILER_MSVC = 1 };
+ #ifndef va_copy
+ // Define va_copy for MSVC. This is a hack, assuming va_list is simply a
+--- b/toolkit/components/protobuf/src/google/protobuf/stubs/strutil.h
++++ a/toolkit/components/protobuf/src/google/protobuf/stubs/strutil.h
+@@ -332,16 +332,17 @@
+ return strtoul(nptr, endptr, base);
+ else
+ return strtou32_adaptor(nptr, endptr, base);
+ }
+
+ // For now, long long is 64-bit on all the platforms we care about, so these
+ // functions can simply pass the call to strto[u]ll.
+ inline int64 strto64(const char *nptr, char **endptr, int base) {
++ static_assert(sizeof(int64) == sizeof(long long), "Protobuf needs sizeof(int64) == sizeof(long long)");
+ GOOGLE_COMPILE_ASSERT(sizeof(int64) == sizeof(long long),
+ sizeof_int64_is_not_sizeof_long_long);
+ return strtoll(nptr, endptr, base);
+ }
+
+ inline uint64 strtou64(const char *nptr, char **endptr, int base) {
+ GOOGLE_COMPILE_ASSERT(sizeof(uint64) == sizeof(unsigned long long),
+ sizeof_uint64_is_not_sizeof_long_long);
+--- a/toolkit/components/protobuf/src/google/protobuf/stubs/strutil.cc
++++ b/toolkit/components/protobuf/src/google/protobuf/stubs/strutil.cc
+@@ -33,16 +33,18 @@
+ #include <google/protobuf/stubs/strutil.h>
+ #include <errno.h>
+ #include <float.h> // FLT_DIG and DBL_DIG
+ #include <limits>
+ #include <limits.h>
+ #include <stdio.h>
+ #include <iterator>
+
++#include "mozilla/FloatingPoint.h"
++
+ #ifdef _WIN32
+ // MSVC has only _snprintf, not snprintf.
+ //
+ // MinGW has both snprintf and _snprintf, but they appear to be different
+ // functions. The former is buggy. When invoked like so:
+ // char buffer[32];
+ // snprintf(buffer, 32, "%.*g\n", FLT_DIG, 1.23e10f);
+ // it prints "1.23000e+10". This is plainly wrong: %g should never print
+@@ -51,18 +53,17 @@
+ // right thing, so we use it.
+ #define snprintf _snprintf
+ #endif
+
+ namespace google {
+ namespace protobuf {
+
+ inline bool IsNaN(double value) {
+- // NaN is never equal to anything, even itself.
+- return value != value;
++ return ::mozilla::IsNaN(value);
+ }
+
+ // These are defined as macros on some platforms. #undef them so that we can
+ // redefine them.
+ #undef isxdigit
+ #undef isprint
+
+ // The definitions of these in ctype.h change based on locale. Since our
+--- b/toolkit/components/protobuf/src/google/protobuf/stubs/type_traits.h
++++ a/toolkit/components/protobuf/src/google/protobuf/stubs/type_traits.h
+@@ -107,20 +107,18 @@
+ template<> struct is_integral<wchar_t> : true_type { };
+ #endif
+ template<> struct is_integral<short> : true_type { };
+ template<> struct is_integral<unsigned short> : true_type { };
+ template<> struct is_integral<int> : true_type { };
+ template<> struct is_integral<unsigned int> : true_type { };
+ template<> struct is_integral<long> : true_type { };
+ template<> struct is_integral<unsigned long> : true_type { };
+-#ifdef HAVE_LONG_LONG
+ template<> struct is_integral<long long> : true_type { };
+ template<> struct is_integral<unsigned long long> : true_type { };
+-#endif
+ template <class T> struct is_integral<const T> : is_integral<T> { };
+ template <class T> struct is_integral<volatile T> : is_integral<T> { };
+ template <class T> struct is_integral<const volatile T> : is_integral<T> { };
+
+ // is_floating_point is false except for the built-in floating-point types.
+ // A cv-qualified type is integral if and only if the underlying type is.
+ template <class T> struct is_floating_point : false_type { };
+ template<> struct is_floating_point<float> : true_type { };
+--- a/toolkit/components/protobuf/src/google/protobuf/wire_format_lite_inl.h
++++ b/toolkit/components/protobuf/src/google/protobuf/wire_format_lite_inl.h
+@@ -375,17 +375,17 @@ inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
+ void* dest = reinterpret_cast<void*>(values->mutable_data() + old_entries);
+ if (!input->ReadRaw(dest, new_bytes)) {
+ values->Truncate(old_entries);
+ return false;
+ }
+ #else
+ values->Reserve(old_entries + new_entries);
+ CType value;
+- for (int i = 0; i < new_entries; ++i) {
++ for (uint32 i = 0; i < new_entries; ++i) {
+ if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+ values->AddAlreadyReserved(value);
+ }
+ #endif
+ } else {
+ // This is the slow-path case where "length" may be too large to
+ // safely allocate. We read as much as we can into *values
+ // without pre-allocating "length" bytes.
+--- a/toolkit/components/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
++++ b/toolkit/components/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
+@@ -39,16 +39,17 @@
+ // streams. Of course, many users will probably want to write their own
+ // implementations of these interfaces specific to the particular I/O
+ // abstractions they prefer to use, but these should cover the most common
+ // cases.
+
+ #ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
+ #define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
+
++#include <vector> /* See Bug 1186561 */
+ #include <string>
+ #include <iosfwd>
+ #include <google/protobuf/io/zero_copy_stream.h>
+ #include <google/protobuf/stubs/common.h>
+ #include <google/protobuf/stubs/stl_util.h>
+
+
+ namespace google {
+diff --git a/toolkit/components/protobuf/src/google/protobuf/stubs/atomicops.h b/toolkit/components/protobuf/src/google/protobuf/stubs/atomicops.h
+--- a/toolkit/components/protobuf/src/google/protobuf/stubs/atomicops.h
++++ b/toolkit/components/protobuf/src/google/protobuf/stubs/atomicops.h
+@@ -73,17 +73,21 @@ typedef int32 Atomic32;
+ typedef int64 Atomic64;
+ #else
+ typedef intptr_t Atomic64;
+ #endif
+ #endif
+
+ // Use AtomicWord for a machine-sized pointer. It will use the Atomic32 or
+ // Atomic64 routines below, depending on your architecture.
++#if defined(__OpenBSD__) && !defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
++typedef Atomic32 AtomicWord;
++#else
+ typedef intptr_t AtomicWord;
++#endif
+
+ // Atomically execute:
+ // result = *ptr;
+ // if (*ptr == old_value)
+ // *ptr = new_value;
+ // return result;
+ //
+ // I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".