Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/python/google/protobuf/pyext/message.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 36 matching lines @@
 
 class Message;
 class Reflection;
 class FieldDescriptor;
 class Descriptor;
 class DescriptorPool;
 class MessageFactory;
 
 #ifdef _SHARED_PTR_H
 using std::shared_ptr;
-using std::string;
+using ::std::string;
 #else
 using internal::shared_ptr;
 #endif
 
 namespace python {
 
 struct ExtensionDict;
-struct PyMessageFactory;
+struct PyDescriptorPool;
 
 typedef struct CMessage {
   PyObject_HEAD;
 
   // This is the top-level C++ Message object that owns the whole
   // proto tree.  Every Python CMessage holds a reference to it in
   // order to keep it alive as long as there's a Python object that
   // references any part of the tree.
   shared_ptr<Message> owner;
 
@@ skipping 29 matching lines @@
   // RepeatedCompositeContainer, and RepeatedScalarContainer
   // objects. Used as a cache to make sure we don't have to make a
   // Python wrapper for the C++ Message objects on every access, or
   // deal with the synchronization nightmare that could create.
   PyObject* composite_fields;
 
   // A reference to the dictionary containing the message's extensions.
   // Similar to composite_fields, acting as a cache, but also contains the
   // required extension dict logic.
   ExtensionDict* extensions;
-
-  // Implements the "weakref" protocol for this object.
-  PyObject* weakreflist;
 } CMessage;
 
-extern PyTypeObject CMessageClass_Type;
 extern PyTypeObject CMessage_Type;
 
 
 // The (meta) type of all Messages classes.
 // It allows us to cache some C++ pointers in the class object itself, they are
 // faster to extract than from the type's dictionary.
 
 struct CMessageClass {
   // This is how CPython subclasses C structures: the base structure must be
   // the first member of the object.
   PyHeapTypeObject super;
 
   // C++ descriptor of this message.
   const Descriptor* message_descriptor;
 
   // Owned reference, used to keep the pointer above alive.
   PyObject* py_message_descriptor;
 
-  // The Python MessageFactory used to create the class. It is needed to resolve
+  // The Python DescriptorPool used to create the class. It is needed to resolve
   // fields descriptors, including extensions fields; its C++ MessageFactory is
   // used to instantiate submessages.
-  // We own the reference, because it's important to keep the factory alive.
-  PyMessageFactory* py_message_factory;
+  // This can be different from DESCRIPTOR.file.pool, in the case of a custom
+  // DescriptorPool which defines new extensions.
+  // We own the reference, because it's important to keep the descriptors and
+  // factory alive.
+  PyDescriptorPool* py_descriptor_pool;
 
   PyObject* AsPyObject() {
     return reinterpret_cast<PyObject*>(this);
   }
 };
 
 
 namespace cmessage {
 
 // Internal function to create a new empty Message Python object, but with empty
 // pointers to the C++ objects.
 // The caller must fill self->message, self->owner and eventually self->parent.
 CMessage* NewEmptyMessage(CMessageClass* type);
 
+// Release a submessage from its proto tree, making it a new top-level messgae.
+// A new message will be created if this is a read-only default instance.
+//
+// Corresponds to reflection api method ReleaseMessage.
+int ReleaseSubMessage(CMessage* self,
+                      const FieldDescriptor* field_descriptor,
+                      CMessage* child_cmessage);
+
 // Retrieves the C++ descriptor of a Python Extension descriptor.
 // On error, return NULL with an exception set.
 const FieldDescriptor* GetExtensionDescriptor(PyObject* extension);
 
 // Initializes a new CMessage instance for a submessage. Only called once per
 // submessage as the result is cached in composite_fields.
 //
 // Corresponds to reflection api method GetMessage.
 PyObject* InternalGetSubMessage(
     CMessage* self, const FieldDescriptor* field_descriptor);
@@ skipping 55 matching lines @@
 // Corresponds to reflection api method HasField
 PyObject* HasFieldByDescriptor(
     CMessage* self, const FieldDescriptor* field_descriptor);
 
 // Checks if the message has the named field.
 //
 // Corresponds to reflection api method HasField.
 PyObject* HasField(CMessage* self, PyObject* arg);
 
 // Initializes values of fields on a newly constructed message.
-// Note that positional arguments are disallowed: 'args' must be NULL or the
-// empty tuple.
-int InitAttributes(CMessage* self, PyObject* args, PyObject* kwargs);
+int InitAttributes(CMessage* self, PyObject* kwargs);
 
 PyObject* MergeFrom(CMessage* self, PyObject* arg);
 
-// This method does not do anything beyond checking that no other extension
-// has been registered with the same field number on this class.
-PyObject* RegisterExtension(PyObject* cls, PyObject* extension_handle);
-
 // Retrieves an attribute named 'name' from CMessage 'self'. Returns
 // the attribute value on success, or NULL on failure.
 //
 // Returns a new reference.
 PyObject* GetAttr(CMessage* self, PyObject* name);
 
 // Set the value of the attribute named 'name', for CMessage 'self',
 // to the value 'value'. Returns -1 on failure.
 int SetAttr(CMessage* self, PyObject* name, PyObject* value);
 
 PyObject* FindInitializationErrors(CMessage* self);
 
 // Set the owner field of self and any children of self, recursively.
 // Used when self is being released and thus has a new owner (the
 // released Message.)
 int SetOwner(CMessage* self, const shared_ptr<Message>& new_owner);
 
 int AssureWritable(CMessage* self);
 
-// Returns the message factory for the given message.
-// This is equivalent to message.MESSAGE_FACTORY
+// Returns the "best" DescriptorPool for the given message.
+// This is often equivalent to message.DESCRIPTOR.pool, but not always, when
+// the message class was created from a MessageFactory using a custom pool which
+// uses the generated pool as an underlay.
 //
-// The returned factory is suitable for finding fields and building submessages,
+// The returned pool is suitable for finding fields and building submessages,
 // even in the case of extensions.
-// Returns a *borrowed* reference, and never fails because we pass a CMessage.
-PyMessageFactory* GetFactoryForMessage(CMessage* message);
-
-PyObject* SetAllowOversizeProtos(PyObject* m, PyObject* arg);
+PyDescriptorPool* GetDescriptorPoolForMessage(CMessage* message);
 
 }  // namespace cmessage
 
 
 /* Is 64bit */
 #define IS_64BIT (SIZEOF_LONG == 8)
 
 #define FIELD_IS_REPEATED(field_descriptor)                 \
     ((field_descriptor)->label() == FieldDescriptor::LABEL_REPEATED)
 
 #define GOOGLE_CHECK_GET_INT32(arg, value, err)                        \
     int32 value;                                            \
-    if (!CheckAndGetInteger(arg, &value)) { \
+    if (!CheckAndGetInteger(arg, &value, kint32min_py, kint32max_py)) { \
       return err;                                          \
     }
 
 #define GOOGLE_CHECK_GET_INT64(arg, value, err)                        \
     int64 value;                                            \
-    if (!CheckAndGetInteger(arg, &value)) { \
+    if (!CheckAndGetInteger(arg, &value, kint64min_py, kint64max_py)) { \
       return err;                                          \
     }
 
 #define GOOGLE_CHECK_GET_UINT32(arg, value, err)                       \
     uint32 value;                                           \
-    if (!CheckAndGetInteger(arg, &value)) { \
+    if (!CheckAndGetInteger(arg, &value, kPythonZero, kuint32max_py)) { \
       return err;                                          \
     }
 
 #define GOOGLE_CHECK_GET_UINT64(arg, value, err)                       \
     uint64 value;                                           \
-    if (!CheckAndGetInteger(arg, &value)) { \
+    if (!CheckAndGetInteger(arg, &value, kPythonZero, kuint64max_py)) { \
       return err;                                          \
     }
 
 #define GOOGLE_CHECK_GET_FLOAT(arg, value, err)                        \
     float value;                                            \
     if (!CheckAndGetFloat(arg, &value)) {                   \
       return err;                                          \
     }                                                       \
 
 #define GOOGLE_CHECK_GET_DOUBLE(arg, value, err)                       \
     double value;                                           \
     if (!CheckAndGetDouble(arg, &value)) {                  \
       return err;                                          \
     }
 
 #define GOOGLE_CHECK_GET_BOOL(arg, value, err)                         \
     bool value;                                             \
     if (!CheckAndGetBool(arg, &value)) {                    \
       return err;                                          \
     }
 
 
+extern PyObject* kPythonZero;
+extern PyObject* kint32min_py;
+extern PyObject* kint32max_py;
+extern PyObject* kuint32max_py;
+extern PyObject* kint64min_py;
+extern PyObject* kint64max_py;
+extern PyObject* kuint64max_py;
+
 #define FULL_MODULE_NAME "google.protobuf.pyext._message"
 
 void FormatTypeError(PyObject* arg, char* expected_types);
 template<class T>
-bool CheckAndGetInteger(PyObject* arg, T* value);
+bool CheckAndGetInteger(
+    PyObject* arg, T* value, PyObject* min, PyObject* max);
 bool CheckAndGetDouble(PyObject* arg, double* value);
 bool CheckAndGetFloat(PyObject* arg, float* value);
 bool CheckAndGetBool(PyObject* arg, bool* value);
 PyObject* CheckString(PyObject* arg, const FieldDescriptor* descriptor);
 bool CheckAndSetString(
     PyObject* arg, Message* message,
     const FieldDescriptor* descriptor,
     const Reflection* reflection,
     bool append,
     int index);
 PyObject* ToStringObject(const FieldDescriptor* descriptor, string value);
 
 // Check if the passed field descriptor belongs to the given message.
 // If not, return false and set a Python exception (a KeyError)
 bool CheckFieldBelongsToMessage(const FieldDescriptor* field_descriptor,
                                 const Message* message);
 
 extern PyObject* PickleError_class;
 
-bool InitProto2MessageModule(PyObject *m);
-
 }  // namespace python
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_PYTHON_CPP_MESSAGE_H__