Revert https://codereview.chromium.org/1291903002 (protobuf roll).

third_party/protobuf/objectivec/GPBCodedInputStream.m

Index: third_party/protobuf/objectivec/GPBCodedInputStream.m
diff --git a/third_party/protobuf/objectivec/GPBCodedInputStream.m b/third_party/protobuf/objectivec/GPBCodedInputStream.m
deleted file mode 100644
index 71758baa6bb691c6775cd9efc505264a96771f0e..0000000000000000000000000000000000000000
--- a/third_party/protobuf/objectivec/GPBCodedInputStream.m
+++ /dev/null
@@ -1,801 +0,0 @@
-// 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.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#import "GPBCodedInputStream_PackagePrivate.h"
-
-#import "GPBDictionary_PackagePrivate.h"
-#import "GPBMessage_PackagePrivate.h"
-#import "GPBUnknownFieldSet_PackagePrivate.h"
-#import "GPBUtilities_PackagePrivate.h"
-#import "GPBWireFormat.h"
-
-static const NSUInteger kDefaultRecursionLimit = 64;
-
-static void CheckSize(GPBCodedInputStreamState *state, size_t size) {
-  size_t newSize = state->bufferPos + size;
-  if (newSize > state->bufferSize) {
-    [NSException raise:NSParseErrorException format:@""];
-  }
-  if (newSize > state->currentLimit) {
-    // Fast forward to end of currentLimit;
-    state->bufferPos = state->currentLimit;
-    [NSException raise:NSParseErrorException format:@""];
-  }
-}
-
-static int8_t ReadRawByte(GPBCodedInputStreamState *state) {
-  CheckSize(state, sizeof(int8_t));
-  return ((int8_t *)state->bytes)[state->bufferPos++];
-}
-
-static int32_t ReadRawLittleEndian32(GPBCodedInputStreamState *state) {
-  CheckSize(state, sizeof(int32_t));
-  int32_t value = OSReadLittleInt32(state->bytes, state->bufferPos);
-  state->bufferPos += sizeof(int32_t);
-  return value;
-}
-
-static int64_t ReadRawLittleEndian64(GPBCodedInputStreamState *state) {
-  CheckSize(state, sizeof(int64_t));
-  int64_t value = OSReadLittleInt64(state->bytes, state->bufferPos);
-  state->bufferPos += sizeof(int64_t);
-  return value;
-}
-
-static int32_t ReadRawVarint32(GPBCodedInputStreamState *state) {
-  int8_t tmp = ReadRawByte(state);
-  if (tmp >= 0) {
-    return tmp;
-  }
-  int32_t result = tmp & 0x7f;
-  if ((tmp = ReadRawByte(state)) >= 0) {
-    result |= tmp << 7;
-  } else {
-    result |= (tmp & 0x7f) << 7;
-    if ((tmp = ReadRawByte(state)) >= 0) {
-      result |= tmp << 14;
-    } else {
-      result |= (tmp & 0x7f) << 14;
-      if ((tmp = ReadRawByte(state)) >= 0) {
-        result |= tmp << 21;
-      } else {
-        result |= (tmp & 0x7f) << 21;
-        result |= (tmp = ReadRawByte(state)) << 28;
-        if (tmp < 0) {
-          // Discard upper 32 bits.
-          for (int i = 0; i < 5; i++) {
-            if (ReadRawByte(state) >= 0) {
-              return result;
-            }
-          }
-          [NSException raise:NSParseErrorException
-                      format:@"Unable to read varint32"];
-        }
-      }
-    }
-  }
-  return result;
-}
-
-static int64_t ReadRawVarint64(GPBCodedInputStreamState *state) {
-  int32_t shift = 0;
-  int64_t result = 0;
-  while (shift < 64) {
-    int8_t b = ReadRawByte(state);
-    result |= (int64_t)(b & 0x7F) << shift;
-    if ((b & 0x80) == 0) {
-      return result;
-    }
-    shift += 7;
-  }
-  [NSException raise:NSParseErrorException format:@"Unable to read varint64"];
-  return 0;
-}
-
-static void SkipRawData(GPBCodedInputStreamState *state, size_t size) {
-  CheckSize(state, size);
-  state->bufferPos += size;
-}
-
-double GPBCodedInputStreamReadDouble(GPBCodedInputStreamState *state) {
-  int64_t value = ReadRawLittleEndian64(state);
-  return GPBConvertInt64ToDouble(value);
-}
-
-float GPBCodedInputStreamReadFloat(GPBCodedInputStreamState *state) {
-  int32_t value = ReadRawLittleEndian32(state);
-  return GPBConvertInt32ToFloat(value);
-}
-
-uint64_t GPBCodedInputStreamReadUInt64(GPBCodedInputStreamState *state) {
-  uint64_t value = ReadRawVarint64(state);
-  return value;
-}
-
-uint32_t GPBCodedInputStreamReadUInt32(GPBCodedInputStreamState *state) {
-  uint32_t value = ReadRawVarint32(state);
-  return value;
-}
-
-int64_t GPBCodedInputStreamReadInt64(GPBCodedInputStreamState *state) {
-  int64_t value = ReadRawVarint64(state);
-  return value;
-}
-
-int32_t GPBCodedInputStreamReadInt32(GPBCodedInputStreamState *state) {
-  int32_t value = ReadRawVarint32(state);
-  return value;
-}
-
-uint64_t GPBCodedInputStreamReadFixed64(GPBCodedInputStreamState *state) {
-  uint64_t value = ReadRawLittleEndian64(state);
-  return value;
-}
-
-uint32_t GPBCodedInputStreamReadFixed32(GPBCodedInputStreamState *state) {
-  uint32_t value = ReadRawLittleEndian32(state);
-  return value;
-}
-
-int32_t GPBCodedInputStreamReadEnum(GPBCodedInputStreamState *state) {
-  int32_t value = ReadRawVarint32(state);
-  return value;
-}
-
-int32_t GPBCodedInputStreamReadSFixed32(GPBCodedInputStreamState *state) {
-  int32_t value = ReadRawLittleEndian32(state);
-  return value;
-}
-
-int64_t GPBCodedInputStreamReadSFixed64(GPBCodedInputStreamState *state) {
-  int64_t value = ReadRawLittleEndian64(state);
-  return value;
-}
-
-int32_t GPBCodedInputStreamReadSInt32(GPBCodedInputStreamState *state) {
-  int32_t value = GPBDecodeZigZag32(ReadRawVarint32(state));
-  return value;
-}
-
-int64_t GPBCodedInputStreamReadSInt64(GPBCodedInputStreamState *state) {
-  int64_t value = GPBDecodeZigZag64(ReadRawVarint64(state));
-  return value;
-}
-
-BOOL GPBCodedInputStreamReadBool(GPBCodedInputStreamState *state) {
-  return ReadRawVarint32(state) != 0;
-}
-
-int32_t GPBCodedInputStreamReadTag(GPBCodedInputStreamState *state) {
-  if (GPBCodedInputStreamIsAtEnd(state)) {
-    state->lastTag = 0;
-    return 0;
-  }
-
-  state->lastTag = ReadRawVarint32(state);
-  if (state->lastTag == 0) {
-    // If we actually read zero, that's not a valid tag.
-    [NSException raise:NSParseErrorException
-                format:@"Invalid last tag %d", state->lastTag];
-  }
-  return state->lastTag;
-}
-
-NSString *GPBCodedInputStreamReadRetainedString(
-    GPBCodedInputStreamState *state) {
-  int32_t size = ReadRawVarint32(state);
-  NSString *result;
-  if (size == 0) {
-    result = @"";
-  } else {
-    CheckSize(state, size);
-    result = GPBCreateGPBStringWithUTF8(&state->bytes[state->bufferPos], size);
-    state->bufferPos += size;
-  }
-  return result;
-}
-
-NSData *GPBCodedInputStreamReadRetainedBytes(GPBCodedInputStreamState *state) {
-  int32_t size = ReadRawVarint32(state);
-  if (size < 0) return nil;
-  CheckSize(state, size);
-  NSData *result = [[NSData alloc] initWithBytes:state->bytes + state->bufferPos
-                                          length:size];
-  state->bufferPos += size;
-  return result;
-}
-
-NSData *GPBCodedInputStreamReadRetainedBytesNoCopy(
-    GPBCodedInputStreamState *state) {
-  int32_t size = ReadRawVarint32(state);
-  if (size < 0) return nil;
-  CheckSize(state, size);
-  // Cast is safe because freeWhenDone is NO.
-  NSData *result = [[NSData alloc]
-      initWithBytesNoCopy:(void *)(state->bytes + state->bufferPos)
-                   length:size
-             freeWhenDone:NO];
-  state->bufferPos += size;
-  return result;
-}
-
-size_t GPBCodedInputStreamPushLimit(GPBCodedInputStreamState *state,
-                                    size_t byteLimit) {
-  byteLimit += state->bufferPos;
-  size_t oldLimit = state->currentLimit;
-  if (byteLimit > oldLimit) {
-    [NSException raise:NSInvalidArgumentException
-                format:@"byteLimit > oldLimit: %tu > %tu", byteLimit, oldLimit];
-  }
-  state->currentLimit = byteLimit;
-  return oldLimit;
-}
-
-void GPBCodedInputStreamPopLimit(GPBCodedInputStreamState *state,
-                                 size_t oldLimit) {
-  state->currentLimit = oldLimit;
-}
-
-size_t GPBCodedInputStreamBytesUntilLimit(GPBCodedInputStreamState *state) {
-  if (state->currentLimit == SIZE_T_MAX) {
-    return state->currentLimit;
-  }
-
-  return state->currentLimit - state->bufferPos;
-}
-
-BOOL GPBCodedInputStreamIsAtEnd(GPBCodedInputStreamState *state) {
-  return (state->bufferPos == state->bufferSize) ||
-         (state->bufferPos == state->currentLimit);
-}
-
-void GPBCodedInputStreamCheckLastTagWas(GPBCodedInputStreamState *state,
-                                        int32_t value) {
-  if (state->lastTag != value) {
-    [NSException raise:NSParseErrorException
-                format:@"Last tag: %d should be %d", state->lastTag, value];
-  }
-}
-
-@implementation GPBCodedInputStream
-
-+ (instancetype)streamWithData:(NSData *)data {
-  return [[[self alloc] initWithData:data] autorelease];
-}
-
-- (instancetype)initWithData:(NSData *)data {
-  if ((self = [super init])) {
-#ifdef DEBUG
-    NSCAssert([self class] == [GPBCodedInputStream class],
-              @"Subclassing of GPBCodedInputStream is not allowed.");
-#endif
-    buffer_ = [data retain];
-    state_.bytes = (const uint8_t *)[data bytes];
-    state_.bufferSize = [data length];
-    state_.currentLimit = NSUIntegerMax;
-  }
-  return self;
-}
-
-- (void)dealloc {
-  [buffer_ release];
-  [super dealloc];
-}
-
-- (int32_t)readTag {
-  return GPBCodedInputStreamReadTag(&state_);
-}
-
-- (void)checkLastTagWas:(int32_t)value {
-  GPBCodedInputStreamCheckLastTagWas(&state_, value);
-}
-
-- (BOOL)skipField:(int32_t)tag {
-  switch (GPBWireFormatGetTagWireType(tag)) {
-    case GPBWireFormatVarint:
-      GPBCodedInputStreamReadInt32(&state_);
-      return YES;
-    case GPBWireFormatFixed64:
-      SkipRawData(&state_, sizeof(int64_t));
-      return YES;
-    case GPBWireFormatLengthDelimited:
-      SkipRawData(&state_, ReadRawVarint32(&state_));
-      return YES;
-    case GPBWireFormatStartGroup:
-      [self skipMessage];
-      GPBCodedInputStreamCheckLastTagWas(
-          &state_, GPBWireFormatMakeTag(GPBWireFormatGetTagFieldNumber(tag),
-                                        GPBWireFormatEndGroup));
-      return YES;
-    case GPBWireFormatEndGroup:
-      return NO;
-    case GPBWireFormatFixed32:
-      SkipRawData(&state_, sizeof(int32_t));
-      return YES;
-  }
-  [NSException raise:NSParseErrorException format:@"Invalid tag %d", tag];
-  return NO;
-}
-
-- (void)skipMessage {
-  while (YES) {
-    int32_t tag = GPBCodedInputStreamReadTag(&state_);
-    if (tag == 0 || ![self skipField:tag]) {
-      return;
-    }
-  }
-}
-
-- (double)readDouble {
-  return GPBCodedInputStreamReadDouble(&state_);
-}
-
-- (float)readFloat {
-  return GPBCodedInputStreamReadFloat(&state_);
-}
-
-- (uint64_t)readUInt64 {
-  return GPBCodedInputStreamReadUInt64(&state_);
-}
-
-- (int64_t)readInt64 {
-  return GPBCodedInputStreamReadInt64(&state_);
-}
-
-- (int32_t)readInt32 {
-  return GPBCodedInputStreamReadInt32(&state_);
-}
-
-- (uint64_t)readFixed64 {
-  return GPBCodedInputStreamReadFixed64(&state_);
-}
-
-- (uint32_t)readFixed32 {
-  return GPBCodedInputStreamReadFixed32(&state_);
-}
-
-- (BOOL)readBool {
-  return GPBCodedInputStreamReadBool(&state_);
-}
-
-- (NSString *)readString {
-  return [GPBCodedInputStreamReadRetainedString(&state_) autorelease];
-}
-
-- (void)readGroup:(int32_t)fieldNumber
-              message:(GPBMessage *)message
-    extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
-  if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
-  }
-  ++state_.recursionDepth;
-  [message mergeFromCodedInputStream:self extensionRegistry:extensionRegistry];
-  GPBCodedInputStreamCheckLastTagWas(
-      &state_, GPBWireFormatMakeTag(fieldNumber, GPBWireFormatEndGroup));
-  --state_.recursionDepth;
-}
-
-- (void)readUnknownGroup:(int32_t)fieldNumber
-                 message:(GPBUnknownFieldSet *)message {
-  if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
-  }
-  ++state_.recursionDepth;
-  [message mergeFromCodedInputStream:self];
-  GPBCodedInputStreamCheckLastTagWas(
-      &state_, GPBWireFormatMakeTag(fieldNumber, GPBWireFormatEndGroup));
-  --state_.recursionDepth;
-}
-
-- (void)readMessage:(GPBMessage *)message
-    extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
-  int32_t length = ReadRawVarint32(&state_);
-  if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
-  }
-  size_t oldLimit = GPBCodedInputStreamPushLimit(&state_, length);
-  ++state_.recursionDepth;
-  [message mergeFromCodedInputStream:self extensionRegistry:extensionRegistry];
-  GPBCodedInputStreamCheckLastTagWas(&state_, 0);
-  --state_.recursionDepth;
-  GPBCodedInputStreamPopLimit(&state_, oldLimit);
-}
-
-- (void)readMapEntry:(id)mapDictionary
-    extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
-                field:(GPBFieldDescriptor *)field
-        parentMessage:(GPBMessage *)parentMessage {
-  int32_t length = ReadRawVarint32(&state_);
-  if (state_.recursionDepth >= kDefaultRecursionLimit) {
-    [NSException raise:NSParseErrorException
-                format:@"recursionDepth(%tu) >= %tu", state_.recursionDepth,
-                       kDefaultRecursionLimit];
-  }
-  size_t oldLimit = GPBCodedInputStreamPushLimit(&state_, length);
-  ++state_.recursionDepth;
-  GPBDictionaryReadEntry(mapDictionary, self, extensionRegistry, field,
-                         parentMessage);
-  GPBCodedInputStreamCheckLastTagWas(&state_, 0);
-  --state_.recursionDepth;
-  GPBCodedInputStreamPopLimit(&state_, oldLimit);
-}
-
-- (NSData *)readBytes {
-  return [GPBCodedInputStreamReadRetainedBytes(&state_) autorelease];
-}
-
-- (uint32_t)readUInt32 {
-  return GPBCodedInputStreamReadUInt32(&state_);
-}
-
-- (int32_t)readEnum {
-  return GPBCodedInputStreamReadEnum(&state_);
-}
-
-- (int32_t)readSFixed32 {
-  return GPBCodedInputStreamReadSFixed32(&state_);
-}
-
-- (int64_t)readSFixed64 {
-  return GPBCodedInputStreamReadSFixed64(&state_);
-}
-
-- (int32_t)readSInt32 {
-  return GPBCodedInputStreamReadSInt32(&state_);
-}
-
-- (int64_t)readSInt64 {
-  return GPBCodedInputStreamReadSInt64(&state_);
-}
-
-@end
-
-@implementation GPBString {
- @package
-  CFStringRef string_;
-  unsigned char *utf8_;
-  NSUInteger utf8Len_;
-
-  // This lock is used to gate access to utf8_.  Once GPBStringInitStringValue()
-  // has been called, string_ will be filled in, and utf8_ will be NULL.
-  OSSpinLock lock_;
-
-  BOOL hasBOM_;
-  BOOL is7BitAscii_;
-}
-
-// Returns true if the passed in bytes are 7 bit ascii.
-// This routine needs to be fast.
-static bool AreBytesIn7BitASCII(const uint8_t *bytes, NSUInteger len) {
-// In the loops below, it's more efficient to collect rather than do
-// conditional at every step.
-#if __LP64__
-  // Align bytes. This is especially important in case of 3 byte BOM.
-  while (len > 0 && ((size_t)bytes & 0x07)) {
-    if (*bytes++ & 0x80) return false;
-    len--;
-  }
-  while (len >= 32) {
-    uint64_t val = *(const uint64_t *)bytes;
-    uint64_t hiBits = (val & 0x8080808080808080ULL);
-    bytes += 8;
-    val = *(const uint64_t *)bytes;
-    hiBits |= (val & 0x8080808080808080ULL);
-    bytes += 8;
-    val = *(const uint64_t *)bytes;
-    hiBits |= (val & 0x8080808080808080ULL);
-    bytes += 8;
-    val = *(const uint64_t *)bytes;
-    if (hiBits | (val & 0x8080808080808080ULL)) return false;
-    bytes += 8;
-    len -= 32;
-  }
-
-  while (len >= 16) {
-    uint64_t val = *(const uint64_t *)bytes;
-    uint64_t hiBits = (val & 0x8080808080808080ULL);
-    bytes += 8;
-    val = *(const uint64_t *)bytes;
-    if (hiBits | (val & 0x8080808080808080ULL)) return false;
-    bytes += 8;
-    len -= 16;
-  }
-
-  while (len >= 8) {
-    uint64_t val = *(const uint64_t *)bytes;
-    if (val & 0x8080808080808080ULL) return false;
-    bytes += 8;
-    len -= 8;
-  }
-#else   // __LP64__
-  // Align bytes. This is especially important in case of 3 byte BOM.
-  while (len > 0 && ((size_t)bytes & 0x03)) {
-    if (*bytes++ & 0x80) return false;
-    len--;
-  }
-  while (len >= 16) {
-    uint32_t val = *(const uint32_t *)bytes;
-    uint32_t hiBits = (val & 0x80808080U);
-    bytes += 4;
-    val = *(const uint32_t *)bytes;
-    hiBits |= (val & 0x80808080U);
-    bytes += 4;
-    val = *(const uint32_t *)bytes;
-    hiBits |= (val & 0x80808080U);
-    bytes += 4;
-    val = *(const uint32_t *)bytes;
-    if (hiBits | (val & 0x80808080U)) return false;
-    bytes += 4;
-    len -= 16;
-  }
-
-  while (len >= 8) {
-    uint32_t val = *(const uint32_t *)bytes;
-    uint32_t hiBits = (val & 0x80808080U);
-    bytes += 4;
-    val = *(const uint32_t *)bytes;
-    if (hiBits | (val & 0x80808080U)) return false;
-    bytes += 4;
-    len -= 8;
-  }
-#endif  // __LP64__
-
-  while (len >= 4) {
-    uint32_t val = *(const uint32_t *)bytes;
-    if (val & 0x80808080U) return false;
-    bytes += 4;
-    len -= 4;
-  }
-
-  while (len--) {
-    if (*bytes++ & 0x80) return false;
-  }
-
-  return true;
-}
-
-static void GPBStringInitStringValue(GPBString *string) {
-  OSSpinLockLock(&string->lock_);
-  GPBStringInitStringValueAlreadyLocked(string);
-  OSSpinLockUnlock(&string->lock_);
-}
-
-static void GPBStringInitStringValueAlreadyLocked(GPBString *string) {
-  if (string->string_ == NULL && string->utf8_ != NULL) {
-    // Using kCFAllocatorMalloc for contentsDeallocator, as buffer in
-    // string->utf8_ is being handed off.
-    string->string_ = CFStringCreateWithBytesNoCopy(
-        NULL, string->utf8_, string->utf8Len_, kCFStringEncodingUTF8, false,
-        kCFAllocatorMalloc);
-    if (!string->string_) {
-#ifdef DEBUG
-      // https://developers.google.com/protocol-buffers/docs/proto#scalar
-      NSLog(@"UTF8 failure, is some field type 'string' when it should be "
-            @"'bytes'?");
-#endif
-      string->string_ = CFSTR("");
-      string->utf8Len_ = 0;
-      // On failure, we have to clean up the buffer.
-      free(string->utf8_);
-    }
-    string->utf8_ = NULL;
-  }
-}
-
-GPBString *GPBCreateGPBStringWithUTF8(const void *bytes, NSUInteger length) {
-  GPBString *result = [[GPBString alloc] initWithBytes:bytes length:length];
-  return result;
-}
-
-- (instancetype)initWithBytes:(const void *)bytes length:(NSUInteger)length {
-  self = [super init];
-  if (self) {
-    utf8_ = malloc(length);
-    memcpy(utf8_, bytes, length);
-    utf8Len_ = length;
-    lock_ = OS_SPINLOCK_INIT;
-    is7BitAscii_ = AreBytesIn7BitASCII(bytes, length);
-    if (length >= 3 && memcmp(utf8_, "\xef\xbb\xbf", 3) == 0) {
-      // We can't just remove the BOM from the string here, because in the case
-      // where we have > 1 BOM at the beginning of the string, we will remove one,
-      // and the internal NSString we create will remove the next one, and we will
-      // end up with a GPBString != NSString issue.
-      // We also just can't remove all the BOMs because then we would end up with
-      // potential cases where a GPBString and an NSString made with the same
-      // UTF8 buffer would in fact be different.
-      // We record the fact we have a BOM, and use it as necessary to simulate
-      // what NSString would return for various calls.
-      hasBOM_ = YES;
-#if DEBUG
-      // Sending BOMs across the line is just wasting bits.
-      NSLog(@"Bad data? String should not have BOM!");
-#endif  // DEBUG
-    }
-  }
-  return self;
-}
-
-- (void)dealloc {
-  if (string_ != NULL) {
-    CFRelease(string_);
-  }
-  if (utf8_ != NULL) {
-    free(utf8_);
-  }
-  [super dealloc];
-}
-
-// Required NSString overrides.
-- (NSUInteger)length {
-  if (is7BitAscii_) {
-    return utf8Len_;
-  } else {
-    GPBStringInitStringValue(self);
-    return CFStringGetLength(string_);
-  }
-}
-
-- (unichar)characterAtIndex:(NSUInteger)anIndex {
-  OSSpinLockLock(&lock_);
-  if (is7BitAscii_ && utf8_) {
-    unichar result = utf8_[anIndex];
-    OSSpinLockUnlock(&lock_);
-    return result;
-  } else {
-    GPBStringInitStringValueAlreadyLocked(self);
-    OSSpinLockUnlock(&lock_);
-    return CFStringGetCharacterAtIndex(string_, anIndex);
-  }
-}
-
-// Override a couple of methods that typically want high performance.
-
-- (id)copyWithZone:(NSZone *)zone {
-  GPBStringInitStringValue(self);
-  return [(NSString *)string_ copyWithZone:zone];
-}
-
-- (id)mutableCopyWithZone:(NSZone *)zone {
-  GPBStringInitStringValue(self);
-  return [(NSString *)string_ mutableCopyWithZone:zone];
-}
-
-- (NSUInteger)hash {
-  // Must convert to string here to make sure that the hash is always
-  // consistent no matter what state the GPBString is in.
-  GPBStringInitStringValue(self);
-  return CFHash(string_);
-}
-
-- (BOOL)isEqual:(id)object {
-  if (self == object) {
-    return YES;
-  }
-  if ([object isKindOfClass:[NSString class]]) {
-    GPBStringInitStringValue(self);
-    return CFStringCompare(string_, (CFStringRef)object, 0) ==
-           kCFCompareEqualTo;
-  }
-  return NO;
-}
-
-- (void)getCharacters:(unichar *)buffer range:(NSRange)aRange {
-  OSSpinLockLock(&lock_);
-  if (is7BitAscii_ && utf8_) {
-    unsigned char *bytes = &(utf8_[aRange.location]);
-    for (NSUInteger i = 0; i < aRange.length; ++i) {
-      buffer[i] = bytes[i];
-    }
-    OSSpinLockUnlock(&lock_);
-  } else {
-    GPBStringInitStringValueAlreadyLocked(self);
-    OSSpinLockUnlock(&lock_);
-    CFStringGetCharacters(string_, CFRangeMake(aRange.location, aRange.length),
-                          buffer);
-  }
-}
-
-- (NSUInteger)lengthOfBytesUsingEncoding:(NSStringEncoding)encoding {
-  if ((encoding == NSUTF8StringEncoding) ||
-      (encoding == NSASCIIStringEncoding && is7BitAscii_)) {
-    return utf8Len_ - (hasBOM_ ? 3 : 0);
-  } else {
-    GPBStringInitStringValue(self);
-    return [(NSString *)string_ lengthOfBytesUsingEncoding:encoding];
-  }
-}
-
-- (BOOL)getBytes:(void *)buffer
-         maxLength:(NSUInteger)maxLength
-        usedLength:(NSUInteger *)usedLength
-          encoding:(NSStringEncoding)encoding
-           options:(NSStringEncodingConversionOptions)options
-             range:(NSRange)range
-    remainingRange:(NSRangePointer)remainingRange {
-  // [NSString getBytes:maxLength:usedLength:encoding:options:range:remainingRange]
-  // does not return reliable results if the maxLength argument is 0
-  // (Radar 16385183). Therefore we have special cased it as a slow case so
-  // that it behaves however Apple intends it to behave. It should be a rare
-  // case.
-  //
-  // [NSString getBytes:maxLength:usedLength:encoding:options:range:remainingRange]
-  // does not return reliable results if the range is outside of the strings
-  // length (Radar 16396177). Therefore we have special cased it as a slow
-  // case so that it behaves however Apple intends it to behave.  It should
-  // be a rare case.
-  //
-  // We can optimize the UTF8StringEncoding and NSASCIIStringEncoding with no
-  // options cases.
-  if ((options == 0) &&
-      (encoding == NSUTF8StringEncoding || encoding == NSASCIIStringEncoding) &&
-      (maxLength != 0) &&
-      (NSMaxRange(range) <= utf8Len_)) {
-    // Might be able to optimize it.
-    OSSpinLockLock(&lock_);
-    if (is7BitAscii_ && utf8_) {
-      NSUInteger length = range.length;
-      length = (length < maxLength) ? length : maxLength;
-      memcpy(buffer, utf8_ + range.location, length);
-      if (usedLength) {
-        *usedLength = length;
-      }
-      if (remainingRange) {
-        remainingRange->location = range.location + length;
-        remainingRange->length = range.length - length;
-      }
-      OSSpinLockUnlock(&lock_);
-      if (length > 0) {
-        return YES;
-      } else {
-        return NO;
-      }
-    } else {
-      GPBStringInitStringValueAlreadyLocked(self);
-      OSSpinLockUnlock(&lock_);
-    }
-  } else {
-    GPBStringInitStringValue(self);
-  }
-  return [(NSString *)string_ getBytes:buffer
-                             maxLength:maxLength
-                            usedLength:usedLength
-                              encoding:encoding
-                               options:options
-                                 range:range
-                        remainingRange:remainingRange];
-}
-
-@end