mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 13:45:27 +00:00
411 lines
15 KiB
Diff
411 lines
15 KiB
Diff
--- 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".
|