Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/objectivec/GPBCodedOutputStream.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 126 matching lines @@
   GPBWriteRawByte(state, (int32_t)(value)&0xFF);
   GPBWriteRawByte(state, (int32_t)(value >> 8) & 0xFF);
   GPBWriteRawByte(state, (int32_t)(value >> 16) & 0xFF);
   GPBWriteRawByte(state, (int32_t)(value >> 24) & 0xFF);
   GPBWriteRawByte(state, (int32_t)(value >> 32) & 0xFF);
   GPBWriteRawByte(state, (int32_t)(value >> 40) & 0xFF);
   GPBWriteRawByte(state, (int32_t)(value >> 48) & 0xFF);
   GPBWriteRawByte(state, (int32_t)(value >> 56) & 0xFF);
 }
 
+#if DEBUG && !defined(NS_BLOCK_ASSERTIONS)
++ (void)load {
+  // This test exists to verify that CFStrings with embedded NULLs will work
+  // for us. If this Assert fails, all code below that depends on
+  // CFStringGetCStringPtr will NOT work properly on strings that contain
+  // embedded NULLs, and we do get that in some protobufs.
+  // Note that this will not be compiled in release.
+  // We didn't feel that just keeping it in a unit test was sufficient because
+  // the Protobuf unit tests are only run when somebody is actually working
+  // on protobufs.
+  CFStringRef zeroTest = CFSTR("Test\0String");
+  const char *cString = CFStringGetCStringPtr(zeroTest, kCFStringEncodingUTF8);
+  NSAssert(cString == NULL, @"Serious Error");
+}
+#endif  // DEBUG && !defined(NS_BLOCK_ASSERTIONS)
+
 - (void)dealloc {
   [self flush];
   [state_.output close];
   [state_.output release];
   [buffer_ release];
 
   [super dealloc];
 }
 
 - (instancetype)initWithOutputStream:(NSOutputStream *)output {
@@ skipping 23 matching lines @@
 + (instancetype)streamWithOutputStream:(NSOutputStream *)output {
   NSMutableData *data = [NSMutableData dataWithLength:PAGE_SIZE];
   return [[[self alloc] initWithOutputStream:output
                                         data:data] autorelease];
 }
 
 + (instancetype)streamWithData:(NSMutableData *)data {
   return [[[self alloc] initWithData:data] autorelease];
 }
 
-// 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"
-
 - (void)writeDoubleNoTag:(double)value {
   GPBWriteRawLittleEndian64(&state_, GPBConvertDoubleToInt64(value));
 }
 
 - (void)writeDouble:(int32_t)fieldNumber value:(double)value {
   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatFixed64);
   GPBWriteRawLittleEndian64(&state_, GPBConvertDoubleToInt64(value));
 }
 
 - (void)writeFloatNoTag:(float)value {
@@ skipping 53 matching lines @@
 - (void)writeBoolNoTag:(BOOL)value {
   GPBWriteRawByte(&state_, (value ? 1 : 0));
 }
 
 - (void)writeBool:(int32_t)fieldNumber value:(BOOL)value {
   GPBWriteTagWithFormat(&state_, fieldNumber, GPBWireFormatVarint);
   GPBWriteRawByte(&state_, (value ? 1 : 0));
 }
 
 - (void)writeStringNoTag:(const NSString *)value {
-  size_t length = [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+  // If you are concerned about embedded NULLs see the test in
+  // +load above.
+  const char *quickString =
+      CFStringGetCStringPtr((CFStringRef)value, kCFStringEncodingUTF8);
+  size_t length = (quickString != NULL)
+                      ? strlen(quickString)
+                      : [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
   GPBWriteRawVarint32(&state_, (int32_t)length);
+
   if (length == 0) {
     return;
   }
 
-  const char *quickString =
-      CFStringGetCStringPtr((CFStringRef)value, kCFStringEncodingUTF8);
-
   // Fast path: Most strings are short, if the buffer already has space,
   // add to it directly.
   NSUInteger bufferBytesLeft = state_.size - state_.position;
   if (bufferBytesLeft >= length) {
     NSUInteger usedBufferLength = 0;
     BOOL result;
     if (quickString != NULL) {
       memcpy(state_.bytes + state_.position, quickString, length);
       usedBufferLength = length;
       result = YES;
     } else {
       result = [value getBytes:state_.bytes + state_.position
                      maxLength:bufferBytesLeft
                     usedLength:&usedBufferLength
                       encoding:NSUTF8StringEncoding
-                       options:(NSStringEncodingConversionOptions)0
+                       options:0
                          range:NSMakeRange(0, [value length])
                 remainingRange:NULL];
     }
     if (result) {
       NSAssert2((usedBufferLength == length),
                 @"Our UTF8 calc was wrong? %tu vs %zd", usedBufferLength,
                 length);
       state_.position += usedBufferLength;
       return;
     }
@@ skipping 656 matching lines @@
 }
 
 - (void)writeRawLittleEndian32:(int32_t)value {
   GPBWriteRawLittleEndian32(&state_, value);
 }
 
 - (void)writeRawLittleEndian64:(int64_t)value {
   GPBWriteRawLittleEndian64(&state_, value);
 }
 
-#pragma clang diagnostic pop
-
 @end
 
 size_t GPBComputeDoubleSizeNoTag(Float64 value) {
 #pragma unused(value)
   return LITTLE_ENDIAN_64_SIZE;
 }
 
 size_t GPBComputeFloatSizeNoTag(Float32 value) {
 #pragma unused(value)
   return LITTLE_ENDIAN_32_SIZE;
@@ skipping 29 matching lines @@
 #pragma unused(value)
   return LITTLE_ENDIAN_32_SIZE;
 }
 
 size_t GPBComputeBoolSizeNoTag(BOOL value) {
 #pragma unused(value)
   return 1;
 }
 
 size_t GPBComputeStringSizeNoTag(NSString *value) {
-  NSUInteger length = [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+  // If you are concerned about embedded NULLs see the test in
+  // +load above.
+  const char *quickString =
+      CFStringGetCStringPtr((CFStringRef)value, kCFStringEncodingUTF8);
+  NSUInteger length =
+      (quickString != NULL)
+          ? strlen(quickString)
+          : [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
   return GPBComputeRawVarint32SizeForInteger(length) + length;
 }
 
 size_t GPBComputeGroupSizeNoTag(GPBMessage *value) {
   return [value serializedSize];
 }
 
 size_t GPBComputeUnknownGroupSizeNoTag(GPBUnknownFieldSet *value) {
   return value.serializedSize;
 }
@@ skipping 161 matching lines @@
   if ((value & (0xffffffffffffffffL << 14)) == 0) return 2;
   if ((value & (0xffffffffffffffffL << 21)) == 0) return 3;
   if ((value & (0xffffffffffffffffL << 28)) == 0) return 4;
   if ((value & (0xffffffffffffffffL << 35)) == 0) return 5;
   if ((value & (0xffffffffffffffffL << 42)) == 0) return 6;
   if ((value & (0xffffffffffffffffL << 49)) == 0) return 7;
   if ((value & (0xffffffffffffffffL << 56)) == 0) return 8;
   if ((value & (0xffffffffffffffffL << 63)) == 0) return 9;
   return 10;
 }