From 91ce7d2a476bd04fe525049a37a2f8b2824e9724 Mon Sep 17 00:00:00 2001 From: Eric Erfanian Date: Mon, 5 Jun 2017 13:35:02 -0700 Subject: Update AOSP Dialer source from internal google3 repository at cl/158012278. Test: make, treehugger This CL updates the AOSP Dialer source with all the changes that have gone into the private google3 repository. This includes all the changes from cl/152373142 (4/06/2017) to cl/158012278 (6/05/2017). This goal of these drops is to keep the AOSP source in sync with the internal google3 repository. Currently these sync are done by hand with very minor modifications to the internal source code. See the Android.mk file for list of modifications. Our current goal is to do frequent drops (daily if possible) and eventually switched to an automated process. Change-Id: I4d3f14b5140e2e51bead9497bc118a205b3ebe76 --- java/com/android/dialer/protos/ProtoParsers.java | 125 +++-------------------- 1 file changed, 13 insertions(+), 112 deletions(-) (limited to 'java/com/android/dialer/protos') diff --git a/java/com/android/dialer/protos/ProtoParsers.java b/java/com/android/dialer/protos/ProtoParsers.java index b77c0699b..5a60799bc 100644 --- a/java/com/android/dialer/protos/ProtoParsers.java +++ b/java/com/android/dialer/protos/ProtoParsers.java @@ -18,13 +18,10 @@ package com.android.dialer.protos; import android.content.Intent; import android.os.Bundle; -import android.os.Parcel; -import android.os.Parcelable; +import android.support.annotation.NonNull; import com.android.dialer.common.Assert; -import com.google.protobuf.CodedOutputStream; import com.google.protobuf.InvalidProtocolBufferException; import com.google.protobuf.MessageLite; -import java.io.IOException; /** Useful methods for using Protocol Buffers with Android. */ public final class ProtoParsers { @@ -35,11 +32,8 @@ public final class ProtoParsers { @SuppressWarnings("unchecked") // We want to eventually optimize away parser classes, so cast public static T get(Bundle bundle, String key, T defaultInstance) throws InvalidProtocolBufferException { - // Class loaders are unique to each Class instance, so we need to specify how to decode - // the information again, even though we set the class loaders when serializing the data. - bundle.setClassLoader(ProtoParsers.class.getClassLoader()); - InternalDontUse parcelable = bundle.getParcelable(key); - return (T) parcelable.getMessageUnsafe(defaultInstance.getDefaultInstanceForType()); + byte[] bytes = bundle.getByteArray(key); + return (T) mergeFrom(bytes, defaultInstance.getDefaultInstanceForType()); } /** @@ -51,7 +45,7 @@ public final class ProtoParsers { try { return get(bundle, key, defaultInstance); } catch (InvalidProtocolBufferException e) { - throw new RuntimeException(e); + throw Assert.createIllegalStateFailException(e.toString()); } } @@ -68,121 +62,28 @@ public final class ProtoParsers { * Stores a proto in a Bundle, for later retrieval by {@link #get(Bundle, String, MessageLite)} or * {@link #getFromInstanceState(Bundle, String, MessageLite)}. */ - public static void put(Bundle bundle, String key, MessageLite message) { - bundle.putParcelable(key, new InternalDontUse<>(null, message)); + public static void put( + @NonNull Bundle bundle, @NonNull String key, @NonNull MessageLite message) { + Assert.checkState(message != null); + bundle.putByteArray(key, message.toByteArray()); } /** * Stores a proto in an Intent, for later retrieval by {@link #get(Bundle, String, MessageLite)}. * Needs separate method because Intent has similar to but different API than Bundle. */ - public static void put(Intent intent, String key, MessageLite message) { - intent.putExtra(key, new InternalDontUse<>(null, message)); - } - - /** Returns a {@linkplain Parcelable} representation of this protobuf message. */ - public static ParcelableProto asParcelable(T message) { - return new InternalDontUse<>(null, message); - } - - /** - * A protobuf message that can be stored in a {@link Parcel}. - * - *

Note: This Parcelable can only be used in single app. Attempting to send - * it to another app through an Intent will result in an exception due to Proguard - * obfusation when the target application attempts to load the ParcelableProto class. - */ - public interface ParcelableProto extends Parcelable { - /** - * @throws IllegalStateException if the parceled data does not correspond to the defaultInstance - * type. - */ - T getMessage(T defaultInstance); - } - - /** Public because of Parcelable requirements. Do not use. */ - public static final class InternalDontUse implements ParcelableProto { - /* One of these two fields is always populated - since the bytes field never escapes this - * object, there is no risk of concurrent modification by multiple threads, and volatile - * is sufficient to be thread-safe. */ - private volatile byte[] bytes; - private volatile T message; - - /** - * Ideally, we would have type safety here. However, a static field {@link Creator} is required - * by {@link Parcelable}. Static fields are inherently not type safe, since only 1 exists per - * class (rather than 1 per type). - */ - public static final Parcelable.Creator> CREATOR = - new Creator>() { - @Override - public InternalDontUse createFromParcel(Parcel parcel) { - int serializedSize = parcel.readInt(); - byte[] array = new byte[serializedSize]; - parcel.readByteArray(array); - return new InternalDontUse<>(array, null); - } - - @Override - public InternalDontUse[] newArray(int i) { - return new InternalDontUse[i]; - } - }; - - private InternalDontUse(byte[] bytes, T message) { - Assert.checkArgument(bytes != null || message != null, "Must have a message or bytes"); - this.bytes = bytes; - this.message = message; - } - - @Override - public int describeContents() { - return 0; - } - - @Override - public void writeToParcel(Parcel parcel, int i) { - if (bytes == null) { - final byte[] flatArray = new byte[message.getSerializedSize()]; - try { - message.writeTo(CodedOutputStream.newInstance(flatArray)); - bytes = flatArray; - } catch (IOException impossible) { - throw new AssertionError(impossible); - } - } - parcel.writeInt(bytes.length); - parcel.writeByteArray(bytes); - } - - @Override - public T getMessage(T defaultInstance) { - try { - // The proto should never be invalid if it came from our application, so if it is, throw. - return getMessageUnsafe(defaultInstance); - } catch (InvalidProtocolBufferException e) { - throw new IllegalStateException(e); - } - } - - @SuppressWarnings("unchecked") // We're being deserialized, so there's no real type safety - T getMessageUnsafe(T defaultInstance) throws InvalidProtocolBufferException { - // There's a risk that we'll double-parse the bytes, but that's OK, because it'll end up - // as the same immutable object anyway. - if (message == null) { - message = (T) defaultInstance.toBuilder().mergeFrom(bytes).build(); - } - return message; - } + public static void put(@NonNull Intent intent, @NonNull String key, MessageLite message) { + Assert.checkState(message != null); + intent.putExtra(key, message.toByteArray()); } /** Parses a proto, throwing parser errors as runtime exceptions. */ @SuppressWarnings("unchecked") // We want to eventually optimize away parser classes - public static T mergeFrom(byte[] bytes, T defaultInstance) { + private static T mergeFrom(byte[] bytes, T defaultInstance) { try { return (T) defaultInstance.toBuilder().mergeFrom(bytes).build(); } catch (InvalidProtocolBufferException e) { - throw new RuntimeException(e); + throw Assert.createIllegalStateFailException(e.toString()); } } } -- cgit v1.2.3