Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/src/google/protobuf/generated_message_reflection.cc

 // 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 394 matching lines @@
       SWAP_ARRAYS(INT64 , int64 );
       SWAP_ARRAYS(UINT32, uint32);
       SWAP_ARRAYS(UINT64, uint64);
       SWAP_ARRAYS(FLOAT , float );
       SWAP_ARRAYS(DOUBLE, double);
       SWAP_ARRAYS(BOOL  , bool  );
       SWAP_ARRAYS(ENUM  , int   );
 #undef SWAP_ARRAYS
 
       case FieldDescriptor::CPPTYPE_STRING:
+        switch (field->options().ctype()) {
+          default:  // TODO(kenton):  Support other string reps.
+          case FieldOptions::STRING:
+            MutableRaw<RepeatedPtrFieldBase>(message1, field)->
+                Swap<GenericTypeHandler<string> >(
+                    MutableRaw<RepeatedPtrFieldBase>(message2, field));
+            break;
+        }
+        break;
       case FieldDescriptor::CPPTYPE_MESSAGE:
         if (IsMapFieldInApi(field)) {
           MutableRaw<MapFieldBase>(message1, field)->
             MutableRepeatedField()->
               Swap<GenericTypeHandler<google::protobuf::Message> >(
                 MutableRaw<MapFieldBase>(message2, field)->
                   MutableRepeatedField());
         } else {
           MutableRaw<RepeatedPtrFieldBase>(message1, field)->
             Swap<GenericTypeHandler<google::protobuf::Message> >(
@@ skipping 15 matching lines @@
       SWAP_VALUES(INT32 , int32 );
       SWAP_VALUES(INT64 , int64 );
       SWAP_VALUES(UINT32, uint32);
       SWAP_VALUES(UINT64, uint64);
       SWAP_VALUES(FLOAT , float );
       SWAP_VALUES(DOUBLE, double);
       SWAP_VALUES(BOOL  , bool  );
       SWAP_VALUES(ENUM  , int   );
 #undef SWAP_VALUES
       case FieldDescriptor::CPPTYPE_MESSAGE:
-        std::swap(*MutableRaw<Message*>(message1, field),
-                  *MutableRaw<Message*>(message2, field));
+        if (GetArena(message1) == GetArena(message2)) {
+          std::swap(*MutableRaw<Message*>(message1, field),
+                    *MutableRaw<Message*>(message2, field));
+        } else {
+          Message** sub_msg1 = MutableRaw<Message*>(message1, field);
+          Message** sub_msg2 = MutableRaw<Message*>(message2, field);
+          if (*sub_msg1 == NULL && *sub_msg2 == NULL) break;
+          if (*sub_msg1 && *sub_msg2) {
+            (*sub_msg1)->GetReflection()->Swap(*sub_msg1, *sub_msg2);
+            break;
+          }
+          if (*sub_msg1 == NULL) {
+            *sub_msg1 = (*sub_msg2)->New(message1->GetArena());
+            (*sub_msg1)->CopyFrom(**sub_msg2);
+            ClearField(message2, field);
+          } else {
+            *sub_msg2 = (*sub_msg1)->New(message2->GetArena());
+            (*sub_msg2)->CopyFrom(**sub_msg1);
+            ClearField(message1, field);
+          }
+        }
         break;
 
       case FieldDescriptor::CPPTYPE_STRING:
         switch (field->options().ctype()) {
           default:  // TODO(kenton):  Support other string reps.
           case FieldOptions::STRING:
-            MutableRaw<ArenaStringPtr>(message1, field)->Swap(
-                MutableRaw<ArenaStringPtr>(message2, field));
+            {
+              Arena* arena1 = GetArena(message1);
+              Arena* arena2 = GetArena(message2);
+              ArenaStringPtr* string1 =
+                  MutableRaw<ArenaStringPtr>(message1, field);
+              ArenaStringPtr* string2 =
+                  MutableRaw<ArenaStringPtr>(message2, field);
+              if (arena1 == arena2) {
+                string1->Swap(string2);
+              } else {
+                const string* default_ptr =
+                    &DefaultRaw<ArenaStringPtr>(field).Get(NULL);
+                const string temp = string1->Get(default_ptr);
+                string1->Set(default_ptr, string2->Get(default_ptr), arena1);
+                string2->Set(default_ptr, temp, arena2);
+              }
+            }
             break;
         }
         break;
 
       default:
         GOOGLE_LOG(FATAL) << "Unimplemented type: " << field->cpp_type();
     }
   }
 }
 
@@ skipping 1275 matching lines @@
 
 bool GeneratedMessageReflection::InsertOrLookupMapValue(
     Message* message,
     const FieldDescriptor* field,
     const MapKey& key,
     MapValueRef* val) const {
   USAGE_CHECK(IsMapFieldInApi(field),
               "InsertOrLookupMapValue",
               "Field is not a map field.");
   val->SetType(field->message_type()->FindFieldByName("value")->cpp_type());
-  return MutableRaw<MapFieldBase>(message, field)->InsertMapValue(key, val);
+  return MutableRaw<MapFieldBase>(message, field)->InsertOrLookupMapValue(
+      key, val);
 }
 
 bool GeneratedMessageReflection::DeleteMapValue(
     Message* message,
     const FieldDescriptor* field,
     const MapKey& key) const {
   USAGE_CHECK(IsMapFieldInApi(field),
               "DeleteMapValue",
               "Field is not a map field.");
   return MutableRaw<MapFieldBase>(message, field)->DeleteMapValue(key);
@@ skipping 499 matching lines @@
                                         DescriptorPool::generated_pool(),
                                         MessageFactory::generated_factory(),
                                         object_size,
                                         arena_offset,
                                         is_default_instance_offset);
 }
 
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google