Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java

 // 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 27 matching lines @@
 
 /**
  * A partial implementation of the {@link MessageLite} interface which
  * implements as many methods of that interface as possible in terms of other
  * methods.
  *
  * @author kenton@google.com Kenton Varda
  */
 public abstract class AbstractMessageLite<
     MessageType extends AbstractMessageLite<MessageType, BuilderType>,
-    BuilderType extends AbstractMessageLite.Builder<MessageType, BuilderType>>
+    BuilderType extends AbstractMessageLite.Builder<MessageType, BuilderType>> 
         implements MessageLite {
   protected int memoizedHashCode = 0;
-
+  
   @Override
   public ByteString toByteString() {
     try {
       final ByteString.CodedBuilder out =
         ByteString.newCodedBuilder(getSerializedSize());
       writeTo(out.getCodedOutput());
       return out.build();
     } catch (IOException e) {
-      throw new RuntimeException(getSerializingExceptionMessage("ByteString"), e);
+      throw new RuntimeException(
+        "Serializing to a ByteString threw an IOException (should " +
+        "never happen).", e);
     }
   }
 
   @Override
   public byte[] toByteArray() {
     try {
       final byte[] result = new byte[getSerializedSize()];
       final CodedOutputStream output = CodedOutputStream.newInstance(result);
       writeTo(output);
       output.checkNoSpaceLeft();
       return result;
     } catch (IOException e) {
-      throw new RuntimeException(getSerializingExceptionMessage("byte array"), e);
+      throw new RuntimeException(
+        "Serializing to a byte array threw an IOException " +
+        "(should never happen).", e);
     }
   }
 
   @Override
   public void writeTo(final OutputStream output) throws IOException {
     final int bufferSize =
         CodedOutputStream.computePreferredBufferSize(getSerializedSize());
     final CodedOutputStream codedOutput =
         CodedOutputStream.newInstance(output, bufferSize);
     writeTo(codedOutput);
@@ skipping 14 matching lines @@
 
 
   /**
    * Package private helper method for AbstractParser to create
    * UninitializedMessageException.
    */
   UninitializedMessageException newUninitializedMessageException() {
     return new UninitializedMessageException(this);
   }
 
-  private String getSerializingExceptionMessage(String target) {
-    return "Serializing " + getClass().getName() + " to a " + target
-        + " threw an IOException (should never happen).";
-  }
-
   protected static void checkByteStringIsUtf8(ByteString byteString)
       throws IllegalArgumentException {
     if (!byteString.isValidUtf8()) {
       throw new IllegalArgumentException("Byte string is not UTF-8.");
     }
   }
 
   protected static <T> void addAll(final Iterable<T> values,
       final Collection<? super T> list) {
     Builder.addAll(values, list);
   }
-
+  
   /**
    * A partial implementation of the {@link Message.Builder} interface which
    * implements as many methods of that interface as possible in terms of
    * other methods.
    */
   @SuppressWarnings("unchecked")
   public abstract static class Builder<
       MessageType extends AbstractMessageLite<MessageType, BuilderType>,
       BuilderType extends Builder<MessageType, BuilderType>>
       implements MessageLite.Builder {
@@ skipping 15 matching lines @@
     @Override
     public BuilderType mergeFrom(final ByteString data) throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input = data.newCodedInput();
         mergeFrom(input);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
-        throw new RuntimeException(getReadingExceptionMessage("ByteString"), e);
+        throw new RuntimeException(
+          "Reading from a ByteString threw an IOException (should " +
+          "never happen).", e);
       }
     }
 
     @Override
     public BuilderType mergeFrom(
         final ByteString data, final ExtensionRegistryLite extensionRegistry)
         throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input = data.newCodedInput();
         mergeFrom(input, extensionRegistry);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
-        throw new RuntimeException(getReadingExceptionMessage("ByteString"), e);
+        throw new RuntimeException(
+          "Reading from a ByteString threw an IOException (should " +
+          "never happen).", e);
       }
     }
 
     @Override
     public BuilderType mergeFrom(final byte[] data) throws InvalidProtocolBufferException {
       return mergeFrom(data, 0, data.length);
     }
 
     @Override
     public BuilderType mergeFrom(final byte[] data, final int off, final int len)
         throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input =
             CodedInputStream.newInstance(data, off, len);
         mergeFrom(input);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
-        throw new RuntimeException(getReadingExceptionMessage("byte array"), e);
+        throw new RuntimeException(
+          "Reading from a byte array threw an IOException (should " +
+          "never happen).", e);
       }
     }
 
     @Override
     public BuilderType mergeFrom(final byte[] data, final ExtensionRegistryLite extensionRegistry)
         throws InvalidProtocolBufferException {
       return mergeFrom(data, 0, data.length, extensionRegistry);
     }
 
     @Override
     public BuilderType mergeFrom(
         final byte[] data,
         final int off,
         final int len,
         final ExtensionRegistryLite extensionRegistry)
         throws InvalidProtocolBufferException {
       try {
         final CodedInputStream input =
             CodedInputStream.newInstance(data, off, len);
         mergeFrom(input, extensionRegistry);
         input.checkLastTagWas(0);
         return (BuilderType) this;
       } catch (InvalidProtocolBufferException e) {
         throw e;
       } catch (IOException e) {
-        throw new RuntimeException(getReadingExceptionMessage("byte array"), e);
+        throw new RuntimeException(
+          "Reading from a byte array threw an IOException (should " +
+          "never happen).", e);
       }
     }
 
     @Override
     public BuilderType mergeFrom(final InputStream input) throws IOException {
       final CodedInputStream codedInput = CodedInputStream.newInstance(input);
       mergeFrom(codedInput);
       codedInput.checkLastTagWas(0);
       return (BuilderType) this;
     }
@@ skipping 73 matching lines @@
       final InputStream limitedInput = new LimitedInputStream(input, size);
       mergeFrom(limitedInput, extensionRegistry);
       return true;
     }
 
     @Override
     public boolean mergeDelimitedFrom(final InputStream input) throws IOException {
       return mergeDelimitedFrom(input,
           ExtensionRegistryLite.getEmptyRegistry());
     }
-
+    
     @Override
     @SuppressWarnings("unchecked") // isInstance takes care of this
     public BuilderType mergeFrom(final MessageLite other) {
       if (!getDefaultInstanceForType().getClass().isInstance(other)) {
         throw new IllegalArgumentException(
             "mergeFrom(MessageLite) can only merge messages of the same type.");
       }
-
+        
       return internalMergeFrom((MessageType) other);
     }
-
+    
     protected abstract BuilderType internalMergeFrom(MessageType message);
 
-    private String getReadingExceptionMessage(String target) {
-      return "Reading " + getClass().getName() + " from a " + target
-          + " threw an IOException (should never happen).";
-    }
-
     /**
      * Construct an UninitializedMessageException reporting missing fields in
      * the given message.
      */
     protected static UninitializedMessageException
         newUninitializedMessageException(MessageLite message) {
       return new UninitializedMessageException(message);
     }
 
     /**
@@ skipping 29 matching lines @@
 
     private static void checkForNullValues(final Iterable<?> values) {
       for (final Object value : values) {
         if (value == null) {
           throw new NullPointerException();
         }
       }
     }
   }
 }