Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/ruby/src/main/java/com/google/protobuf/jruby/Utils.java

 /*
  * Protocol Buffers - Google's data interchange format
  * Copyright 2014 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
@@ skipping 46 matching lines @@
 
     public static IRubyObject fieldTypeToRuby(ThreadContext context, DescriptorProtos.FieldDescriptorProto.Type type) {
         return fieldTypeToRuby(context, type.name());
     }
 
     private static IRubyObject fieldTypeToRuby(ThreadContext context, String typeName) {
 
         return context.runtime.newSymbol(typeName.replace("TYPE_", "").toLowerCase());
     }
 
-    public static IRubyObject checkType(ThreadContext context, Descriptors.FieldDescriptor.Type fieldType,
-                                        IRubyObject value, RubyModule typeClass) {
+    public static void checkType(ThreadContext context, Descriptors.FieldDescriptor.Type fieldType,
+                            IRubyObject value, RubyModule typeClass) {
         Ruby runtime = context.runtime;
         Object val;
         switch(fieldType) {
             case INT32:
             case INT64:
             case UINT32:
             case UINT64:
                 if (!isRubyNum(value)) {
                     throw runtime.newTypeError("Expected number type for integral field.");
                 }
@@ skipping 20 matching lines @@
             case DOUBLE:
                 if (!isRubyNum(value))
                     throw runtime.newTypeError("Expected number type for double field.");
                 break;
             case BOOL:
                 if (!(value instanceof RubyBoolean))
                     throw runtime.newTypeError("Invalid argument for boolean field.");
                 break;
             case BYTES:
             case STRING:
-                value = validateStringEncoding(context, fieldType, value);
+                validateStringEncoding(context.runtime, fieldType, value);
                 break;
             case MESSAGE:
                 if (value.getMetaClass() != typeClass) {
                     throw runtime.newTypeError(value, typeClass);
                 }
                 break;
             case ENUM:
                 if (value instanceof RubySymbol) {
                     Descriptors.EnumDescriptor enumDescriptor =
                             ((RubyEnumDescriptor) typeClass.getInstanceVariable(DESCRIPTOR_INSTANCE_VAR)).getDescriptor();
                     val = enumDescriptor.findValueByName(value.asJavaString());
                     if (val == null)
                         throw runtime.newRangeError("Enum value " + value + " is not found.");
                 } else if(!isRubyNum(value)) {
                     throw runtime.newTypeError("Expected number or symbol type for enum field.");
                 }
                 break;
             default:
                 break;
         }
-        return value;
     }
 
     public static IRubyObject wrapPrimaryValue(ThreadContext context, Descriptors.FieldDescriptor.Type fieldType, Object value) {
         Ruby runtime = context.runtime;
         switch (fieldType) {
             case INT32:
                 return runtime.newFixnum((Integer) value);
             case INT64:
                 return runtime.newFixnum((Long) value);
             case UINT32:
                 return runtime.newFixnum(((Integer) value) & (-1l >>> 32));
             case UINT64:
                 long ret = (Long) value;
                 return ret >= 0 ? runtime.newFixnum(ret) :
                         RubyBignum.newBignum(runtime, UINT64_COMPLEMENTARY.add(new BigInteger(ret + "")));
             case FLOAT:
                 return runtime.newFloat((Float) value);
             case DOUBLE:
                 return runtime.newFloat((Double) value);
             case BOOL:
                 return (Boolean) value ? runtime.getTrue() : runtime.getFalse();
-            case BYTES: {
-                IRubyObject wrapped = runtime.newString(((ByteString) value).toStringUtf8());
-                wrapped.setFrozen(true);
-                return wrapped;
-            }
-            case STRING: {
-                IRubyObject wrapped = runtime.newString(value.toString());
-                wrapped.setFrozen(true);
-                return wrapped;
-            }
+            case BYTES:
+                return runtime.newString(((ByteString) value).toStringUtf8());
+            case STRING:
+                return runtime.newString(value.toString());
             default:
                 return runtime.getNil();
         }
     }
 
     public static int num2uint(IRubyObject value) {
         long longVal = RubyNumeric.num2long(value);
         if (longVal > UINT_MAX)
             throw value.getRuntime().newRangeError("Integer " + longVal + " too big to convert to 'unsigned int'");
         long num = longVal;
         if (num > Integer.MAX_VALUE || num < Integer.MIN_VALUE)
             // encode to UINT32
             num = (-longVal ^ (-1l >>> 32) ) + 1;
         RubyNumeric.checkInt(value, num);
         return (int) num;
     }
 
     public static long num2ulong(Ruby runtime, IRubyObject value) {
         if (value instanceof RubyFloat) {
             RubyBignum bignum = RubyBignum.newBignum(runtime, ((RubyFloat) value).getDoubleValue());
             return RubyBignum.big2ulong(bignum);
         } else if (value instanceof RubyBignum) {
             return RubyBignum.big2ulong((RubyBignum) value);
         } else {
             return RubyNumeric.num2long(value);
         }
     }
 
-    public static IRubyObject validateStringEncoding(ThreadContext context, Descriptors.FieldDescriptor.Type type, IRubyObject value) {
+    public static void validateStringEncoding(Ruby runtime, Descriptors.FieldDescriptor.Type type, IRubyObject value) {
         if (!(value instanceof RubyString))
-            throw context.runtime.newTypeError("Invalid argument for string field.");
+            throw runtime.newTypeError("Invalid argument for string field.");
+        Encoding encoding = ((RubyString) value).getEncoding();
         switch(type) {
             case BYTES:
-                value = ((RubyString)value).encode(context, context.runtime.evalScriptlet("Encoding::ASCII_8BIT"));
+                if (encoding != ASCIIEncoding.INSTANCE)
+                    throw runtime.newTypeError("Encoding for bytes fields" +
+                            " must be \"ASCII-8BIT\", but was " + encoding);
                 break;
             case STRING:
-                value = ((RubyString)value).encode(context, context.runtime.evalScriptlet("Encoding::UTF_8"));
+                if (encoding != UTF8Encoding.INSTANCE
+                        && encoding != USASCIIEncoding.INSTANCE)
+                    throw runtime.newTypeError("Encoding for string fields" +
+                            " must be \"UTF-8\" or \"ASCII\", but was " + encoding);
                 break;
             default:
                 break;
         }
-        value.setFrozen(true);
-        return value;
     }
 
     public static void checkNameAvailability(ThreadContext context, String name) {
         if (context.runtime.getObject().getConstantAt(name) != null)
             throw context.runtime.newNameError(name + " is already defined", name);
     }
 
     /**
      * Replace invalid "." in descriptor with __DOT__
      * @param name
@@ skipping 79 matching lines @@
     public static String BADNAME_REPLACEMENT = "__DOT__";
 
     public static String DESCRIPTOR_INSTANCE_VAR = "@descriptor";
 
     public static String EQUAL_SIGN = "=";
 
     private static BigInteger UINT64_COMPLEMENTARY = new BigInteger("18446744073709551616"); //Math.pow(2, 64)
 
     private static long UINT_MAX = 0xffffffffl;
 }