Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/objectivec/GPBUnknownFieldSet.m

 // 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 18 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #import "GPBUnknownFieldSet_PackagePrivate.h"
 
 #import "GPBCodedInputStream_PackagePrivate.h"
 #import "GPBCodedOutputStream.h"
 #import "GPBUnknownField_PackagePrivate.h"
 #import "GPBUtilities.h"
 #import "GPBWireFormat.h"
 
+#pragma mark CFDictionaryKeyCallBacks
+
+// We use a custom dictionary here because our keys are numbers and
+// conversion back and forth from NSNumber was costing us performance.
+// If/when we move to C++ this could be done using a std::map and some
+// careful retain/release calls.
+
+static const void *GPBUnknownFieldSetKeyRetain(CFAllocatorRef allocator,
+                                               const void *value) {
+#pragma unused(allocator)
+  return value;
+}
+
+static void GPBUnknownFieldSetKeyRelease(CFAllocatorRef allocator,
+                                         const void *value) {
+#pragma unused(allocator)
+#pragma unused(value)
+}
+
+static CFStringRef GPBUnknownFieldSetCopyKeyDescription(const void *value) {
+  return CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%d"),
+                                  (int)value);
+}
+
+static Boolean GPBUnknownFieldSetKeyEqual(const void *value1,
+                                          const void *value2) {
+  return value1 == value2;
+}
+
+static CFHashCode GPBUnknownFieldSetKeyHash(const void *value) {
+  return (CFHashCode)value;
+}
+
 #pragma mark Helpers
 
 static void checkNumber(int32_t number) {
   if (number == 0) {
     [NSException raise:NSInvalidArgumentException
                 format:@"Zero is not a valid field number."];
   }
 }
 
 @implementation GPBUnknownFieldSet {
  @package
   CFMutableDictionaryRef fields_;
 }
 
 static void CopyWorker(const void *key, const void *value, void *context) {
 #pragma unused(key)
   GPBUnknownField *field = value;
   GPBUnknownFieldSet *result = context;
 
   GPBUnknownField *copied = [field copy];
   [result addField:copied];
   [copied release];
 }
 
-// Direct access is use for speed, to avoid even internally declaring things
-// read/write, etc. The warning is enabled in the project to ensure code calling
-// protos can turn on -Wdirect-ivar-access without issues.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdirect-ivar-access"
-
 - (id)copyWithZone:(NSZone *)zone {
   GPBUnknownFieldSet *result = [[GPBUnknownFieldSet allocWithZone:zone] init];
   if (fields_) {
     CFDictionaryApplyFunction(fields_, CopyWorker, result);
   }
   return result;
 }
 
 - (void)dealloc {
   if (fields_) {
@@ skipping 35 matching lines @@
   GPBUnknownField *result =
       fields_ ? CFDictionaryGetValue(fields_, (void *)key) : nil;
   return result;
 }
 
 - (NSUInteger)countOfFields {
   return fields_ ? CFDictionaryGetCount(fields_) : 0;
 }
 
 - (NSArray *)sortedFields {
-  if (!fields_) return [NSArray array];
+  if (!fields_) return nil;
   size_t count = CFDictionaryGetCount(fields_);
   ssize_t keys[count];
   GPBUnknownField *values[count];
   CFDictionaryGetKeysAndValues(fields_, (const void **)keys,
                                (const void **)values);
   struct GPBFieldPair {
     ssize_t key;
     GPBUnknownField *value;
   } pairs[count];
   for (size_t i = 0; i < count; ++i) {
@@ skipping 116 matching lines @@
 }
 
 + (BOOL)isFieldTag:(int32_t)tag {
   return GPBWireFormatGetTagWireType(tag) != GPBWireFormatEndGroup;
 }
 
 - (void)addField:(GPBUnknownField *)field {
   int32_t number = [field number];
   checkNumber(number);
   if (!fields_) {
-    // Use a custom dictionary here because the keys are numbers and conversion
-    // back and forth from NSNumber isn't worth the cost.
-    fields_ = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, NULL,
+    CFDictionaryKeyCallBacks keyCallBacks = {
+        // See description above for reason for using custom dictionary.
+        0, GPBUnknownFieldSetKeyRetain, GPBUnknownFieldSetKeyRelease,
+        GPBUnknownFieldSetCopyKeyDescription, GPBUnknownFieldSetKeyEqual,
+        GPBUnknownFieldSetKeyHash,
+    };
+    fields_ = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &keyCallBacks,
                                         &kCFTypeDictionaryValueCallBacks);
   }
   ssize_t key = number;
   CFDictionarySetValue(fields_, (const void *)key, field);
 }
 
 - (GPBUnknownField *)mutableFieldForNumber:(int32_t)number create:(BOOL)create {
   ssize_t key = number;
   GPBUnknownField *existing =
       fields_ ? CFDictionaryGetValue(fields_, (const void *)key) : nil;
@@ skipping 41 matching lines @@
   [input checkLastTagWas:0];
   [input release];
 }
 
 - (void)mergeVarintField:(int32_t)number value:(int32_t)value {
   checkNumber(number);
   [[self mutableFieldForNumber:number create:YES] addVarint:value];
 }
 
 - (BOOL)mergeFieldFrom:(int32_t)tag input:(GPBCodedInputStream *)input {
-  NSAssert(GPBWireFormatIsValidTag(tag), @"Got passed an invalid tag");
   int32_t number = GPBWireFormatGetTagFieldNumber(tag);
   GPBCodedInputStreamState *state = &input->state_;
   switch (GPBWireFormatGetTagWireType(tag)) {
     case GPBWireFormatVarint: {
       GPBUnknownField *field = [self mutableFieldForNumber:number create:YES];
       [field addVarint:GPBCodedInputStreamReadInt64(state)];
       return YES;
     }
     case GPBWireFormatFixed64: {
       GPBUnknownField *field = [self mutableFieldForNumber:number create:YES];
@@ skipping 47 matching lines @@
 - (void)getTags:(int32_t *)tags {
   if (!fields_) return;
   size_t count = CFDictionaryGetCount(fields_);
   ssize_t keys[count];
   CFDictionaryGetKeysAndValues(fields_, (const void **)keys, NULL);
   for (size_t i = 0; i < count; ++i) {
     tags[i] = (int32_t)keys[i];
   }
 }
 
-#pragma clang diagnostic pop
-
 @end