diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index af3ab41..a0b5581 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -25,6 +25,7 @@
 import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.GraphLense;
+import com.android.tools.r8.ir.analysis.proto.GeneratedExtensionRegistryShrinker;
 import com.android.tools.r8.ir.conversion.IRConverter;
 import com.android.tools.r8.ir.desugar.R8NestBasedAccessDesugaring;
 import com.android.tools.r8.ir.optimize.EnumOrdinalMapCollector;
@@ -35,6 +36,7 @@
 import com.android.tools.r8.ir.optimize.UnusedArgumentsCollector;
 import com.android.tools.r8.jar.CfApplicationWriter;
 import com.android.tools.r8.kotlin.Kotlin;
+import com.android.tools.r8.logging.Log;
 import com.android.tools.r8.naming.ClassNameMapper;
 import com.android.tools.r8.naming.Minifier;
 import com.android.tools.r8.naming.NamingLens;
@@ -327,6 +329,16 @@
                 .run(executorService));
 
         Enqueuer enqueuer = new Enqueuer(appView, options, null, compatibility);
+
+        // If shrinking of the generated proto extension registry is enabled, then the Enqueuer
+        // won't trace the dead proto extensions fields. However, for the purpose of member value
+        // propagation, we should keep the dead proto extension fields in the program, such that
+        // member value propagation can find their definitions and the corresponding optimization
+        // info. This is handled by simply marking the dead proto extension types as live after the
+        // Enqueuer has finished. This way we don't actually trace these types.
+        enqueuer.markSkippedProtoExtensionTypesAsLive(
+            options.enableGeneratedExtensionRegistryShrinking);
+
         AppView<AppInfoWithLiveness> appViewWithLiveness =
             appView.setAppInfo(
                 enqueuer.traceApplication(
@@ -356,6 +368,9 @@
                   .withLiveness()
                   .prunedCopyFrom(application, pruner.getRemovedClasses()));
           new AbstractMethodRemover(appView.appInfo().withLiveness()).run();
+
+          // Mark dead proto extensions fields as neither being read nor written.
+          appView.withGeneratedExtensionRegistryShrinker(GeneratedExtensionRegistryShrinker::run);
         }
 
         classesToRetainInnerClassAttributeFor =
@@ -629,6 +644,11 @@
                   executorService,
                   timing));
 
+          if (Log.ENABLED) {
+            appView.withGeneratedExtensionRegistryShrinker(
+                GeneratedExtensionRegistryShrinker::logDeadProtoExtensionFields);
+          }
+
           if (options.isShrinking()) {
             TreePruner pruner = new TreePruner(application, appViewWithLiveness);
             application = pruner.run();
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index 800feb6..1d48684 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -5,6 +5,7 @@
 package com.android.tools.r8.graph;
 
 import com.android.tools.r8.OptionalBool;
+import com.android.tools.r8.ir.analysis.proto.GeneratedExtensionRegistryShrinker;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.shaking.VerticalClassMerger.VerticallyMergedClasses;
@@ -12,6 +13,8 @@
 import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableSet;
 import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.function.Predicate;
 
 public class AppView<T extends AppInfo> implements DexDefinitionSupplier {
@@ -29,6 +32,10 @@
   private final InternalOptions options;
   private RootSet rootSet;
 
+  // Optimizations.
+  private final GeneratedExtensionRegistryShrinker generatedExtensionRegistryShrinker;
+
+  // Optimization results.
   private Predicate<DexType> classesEscapingIntoLibrary = Predicates.alwaysTrue();
   private Set<DexMethod> unneededVisibilityBridgeMethods = ImmutableSet.of();
   private VerticallyMergedClasses verticallyMergedClasses;
@@ -40,6 +47,15 @@
     this.wholeProgramOptimizations = wholeProgramOptimizations;
     this.graphLense = GraphLense.getIdentityLense();
     this.options = options;
+
+    if (enableWholeProgramOptimizations()) {
+      this.generatedExtensionRegistryShrinker =
+          options.enableGeneratedExtensionRegistryShrinking
+              ? new GeneratedExtensionRegistryShrinker(this.withLiveness())
+              : null;
+    } else {
+      this.generatedExtensionRegistryShrinker = null;
+    }
   }
 
   public static <T extends AppInfo> AppView<T> createForD8(T appInfo, InternalOptions options) {
@@ -127,6 +143,21 @@
     return wholeProgramOptimizations == WholeProgramOptimizations.ON;
   }
 
+  public void withGeneratedExtensionRegistryShrinker(
+      Consumer<GeneratedExtensionRegistryShrinker> consumer) {
+    if (generatedExtensionRegistryShrinker != null) {
+      consumer.accept(generatedExtensionRegistryShrinker);
+    }
+  }
+
+  public <U> U withGeneratedExtensionRegistryShrinker(
+      Function<GeneratedExtensionRegistryShrinker, U> fn, U defaultValue) {
+    if (generatedExtensionRegistryShrinker != null) {
+      return fn.apply(generatedExtensionRegistryShrinker);
+    }
+    return defaultValue;
+  }
+
   public GraphLense graphLense() {
     return graphLense;
   }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java
index 975776a..7b4abd6 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfo.java
@@ -11,13 +11,19 @@
 /** Provides immutable access to {@link FieldAccessInfoImpl}. */
 public interface FieldAccessInfo {
 
+  FieldAccessInfoImpl asMutable();
+
   DexField getField();
 
+  DexEncodedMethod getUniqueReadContext();
+
   void forEachIndirectAccess(Consumer<DexField> consumer);
 
   void forEachIndirectAccessWithContexts(BiConsumer<DexField, Set<DexEncodedMethod>> consumer);
 
   boolean isRead();
 
+  boolean isReadOnlyIn(DexEncodedMethod method);
+
   boolean isWritten();
 }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java
index 340d606..1f07f43 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollection.java
@@ -9,5 +9,7 @@
 /** Provides immutable access to {@link FieldAccessInfoCollectionImpl}. */
 public interface FieldAccessInfoCollection<T extends FieldAccessInfo> {
 
+  T get(DexField field);
+
   void forEach(Consumer<T> consumer);
 }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
index 8427d53..1478f2d 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoCollectionImpl.java
@@ -15,6 +15,7 @@
 
   private Map<DexField, FieldAccessInfoImpl> infos = new IdentityHashMap<>();
 
+  @Override
   public FieldAccessInfoImpl get(DexField field) {
     return infos.get(field);
   }
diff --git a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
index 23cb198..6198d50 100644
--- a/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
+++ b/src/main/java/com/android/tools/r8/graph/FieldAccessInfoImpl.java
@@ -37,11 +37,27 @@
   }
 
   @Override
+  public FieldAccessInfoImpl asMutable() {
+    return this;
+  }
+
+  @Override
   public DexField getField() {
     return field;
   }
 
   @Override
+  public DexEncodedMethod getUniqueReadContext() {
+    if (readsWithContexts != null && readsWithContexts.size() == 1) {
+      Set<DexEncodedMethod> contexts = readsWithContexts.values().iterator().next();
+      if (contexts.size() == 1) {
+        return contexts.iterator().next();
+      }
+    }
+    return null;
+  }
+
+  @Override
   public void forEachIndirectAccess(Consumer<DexField> consumer) {
     // There can be indirect reads and writes of the same field reference, so we need to keep track
     // of the previously-seen indirect accesses to avoid reporting duplicates.
@@ -99,6 +115,14 @@
     return readsWithContexts != null && !readsWithContexts.isEmpty();
   }
 
+  @Override
+  public boolean isReadOnlyIn(DexEncodedMethod method) {
+    assert isRead();
+    assert method != null;
+    DexEncodedMethod uniqueReadContext = getUniqueReadContext();
+    return uniqueReadContext != null && uniqueReadContext == method;
+  }
+
   /** Returns true if this field is written by the program. */
   @Override
   public boolean isWritten() {
@@ -123,6 +147,10 @@
         .add(context);
   }
 
+  public void clearReads() {
+    readsWithContexts = null;
+  }
+
   public void clearWrites() {
     writesWithContexts = null;
   }
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedExtensionRegistryShrinker.java b/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedExtensionRegistryShrinker.java
new file mode 100644
index 0000000..e30bf58
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/analysis/proto/GeneratedExtensionRegistryShrinker.java
@@ -0,0 +1,171 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.analysis.proto;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProto;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.FieldAccessInfo;
+import com.android.tools.r8.graph.FieldAccessInfoCollection;
+import com.android.tools.r8.graph.FieldAccessInfoImpl;
+import com.android.tools.r8.logging.Log;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import java.util.function.Consumer;
+
+/**
+ * This optimization is responsible for pruning dead proto extensions.
+ *
+ * <p>When using proto lite, a registry for all proto extensions is created. The generated extension
+ * registry roughly looks as follows:
+ *
+ * <pre>
+ *   class GeneratedExtensionRegistry {
+ *     public static GeneratedMessageLite$GeneratedExtension findLiteExtensionByNumber(
+ *         MessageLite message, int number) {
+ *       ...
+ *       switch (...) {
+ *         case ...:
+ *           return SomeExtension.extensionField;
+ *         case ...:
+ *           return SomeOtherExtension.extensionField;
+ *         ... // Many other cases.
+ *         default:
+ *           return null;
+ *       }
+ *     }
+ *   }
+ * </pre>
+ *
+ * <p>We consider an extension to be dead if it is only accessed via a static-get instruction inside
+ * the GeneratedExtensionRegistry. For such dead extensions, we simply rewrite the static-get
+ * instructions inside the GeneratedExtensionRegistry to null. This ensures that the extensions will
+ * be removed as a result of tree shaking.
+ */
+public class GeneratedExtensionRegistryShrinker {
+
+  static class ProtoReferences {
+
+    public final DexType generatedExtensionType;
+    public final DexType generatedMessageLiteType;
+    public final DexType messageLiteType;
+
+    public final DexString findLiteExtensionByNumberName;
+    public final DexString findLiteExtensionByNumber1Name;
+    public final DexString findLiteExtensionByNumber2Name;
+    public final DexProto findLiteExtensionByNumberProto;
+
+    private ProtoReferences(DexItemFactory factory) {
+      generatedExtensionType =
+          factory.createType(
+              factory.createString(
+                  "Lcom/google/protobuf/GeneratedMessageLite$GeneratedExtension;"));
+      generatedMessageLiteType =
+          factory.createType(factory.createString("Lcom/google/protobuf/GeneratedMessageLite;"));
+      messageLiteType =
+          factory.createType(factory.createString("Lcom/google/protobuf/MessageLite;"));
+      findLiteExtensionByNumberName = factory.createString("findLiteExtensionByNumber");
+      findLiteExtensionByNumber1Name = factory.createString("findLiteExtensionByNumber1");
+      findLiteExtensionByNumber2Name = factory.createString("findLiteExtensionByNumber2");
+      findLiteExtensionByNumberProto =
+          factory.createProto(generatedExtensionType, messageLiteType, factory.intType);
+    }
+
+    public boolean isFindLiteExtensionByNumberMethod(DexMethod method) {
+      if (method.proto == findLiteExtensionByNumberProto) {
+        assert method.name != findLiteExtensionByNumber2Name;
+        return method.name == findLiteExtensionByNumberName
+            || method.name == findLiteExtensionByNumber1Name;
+      }
+      return false;
+    }
+  }
+
+  private final AppView<AppInfoWithLiveness> appView;
+  private final ProtoReferences references;
+
+  public GeneratedExtensionRegistryShrinker(AppView<AppInfoWithLiveness> appView) {
+    assert appView.options().enableGeneratedExtensionRegistryShrinking;
+    this.appView = appView;
+    this.references = new ProtoReferences(appView.dexItemFactory());
+  }
+
+  /**
+   * Will be run after the initial round of tree shaking. This clears the reads and writes to fields
+   * that store dead proto extensions. As a result of this, the member value propagation will
+   * automatically rewrite the reads of this field by null.
+   */
+  public void run() {
+    FieldAccessInfoCollection<?> fieldAccessInfoCollection =
+        appView.appInfo().getFieldAccessInfoCollection();
+    forEachDeadProtoExtensionField(
+        field -> {
+          FieldAccessInfoImpl fieldAccessInfo = fieldAccessInfoCollection.get(field).asMutable();
+          fieldAccessInfo.clearReads();
+          fieldAccessInfo.clearWrites();
+        });
+  }
+
+  public boolean isDeadProtoExtensionField(DexField field) {
+    return isDeadProtoExtensionField(field, appView.appInfo().getFieldAccessInfoCollection());
+  }
+
+  public boolean isDeadProtoExtensionField(
+      DexField field, FieldAccessInfoCollection<?> fieldAccessInfoCollection) {
+    if (field.type != references.generatedExtensionType) {
+      return false;
+    }
+
+    DexEncodedField encodedField = appView.appInfo().resolveField(field);
+    if (encodedField == null) {
+      return false;
+    }
+
+    DexClass clazz = appView.definitionFor(encodedField.field.holder);
+    if (clazz == null || !clazz.isProgramClass()) {
+      return false;
+    }
+
+    if (!appView.isSubtype(clazz.type, references.generatedMessageLiteType).isTrue()) {
+      return false;
+    }
+
+    FieldAccessInfo fieldAccessInfo = fieldAccessInfoCollection.get(encodedField.field);
+    if (fieldAccessInfo == null) {
+      return false;
+    }
+
+    DexEncodedMethod uniqueReadContext = fieldAccessInfo.getUniqueReadContext();
+    return uniqueReadContext != null
+        && references.isFindLiteExtensionByNumberMethod(uniqueReadContext.method);
+  }
+
+  private void forEachDeadProtoExtensionField(Consumer<DexField> consumer) {
+    FieldAccessInfoCollection<?> fieldAccessInfoCollection =
+        appView.appInfo().getFieldAccessInfoCollection();
+    fieldAccessInfoCollection.forEach(
+        info -> {
+          DexField field = info.getField();
+          if (isDeadProtoExtensionField(field)) {
+            consumer.accept(field);
+          }
+        });
+  }
+
+  /** For debugging. */
+  public void logDeadProtoExtensionFields() {
+    if (Log.isLoggingEnabledFor(GeneratedExtensionRegistryShrinker.class)) {
+      forEachDeadProtoExtensionField(
+          field ->
+              System.out.println("Dead proto extension field: `" + field.toSourceString() + "`"));
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/logging/Log.java b/src/main/java/com/android/tools/r8/logging/Log.java
index 6cb91b4..2ed1b30 100644
--- a/src/main/java/com/android/tools/r8/logging/Log.java
+++ b/src/main/java/com/android/tools/r8/logging/Log.java
@@ -5,39 +5,39 @@
 
 public class Log {
 
-  static public final boolean ENABLED = false;
+  public static final boolean ENABLED = false;
 
-  static private final boolean VERBOSE_ENABLED = false;
-  static private final boolean INFO_ENABLED = true;
-  static private final boolean DEBUG_ENABLED = true;
-  static private final boolean WARN_ENABLED = true;
+  private static final boolean VERBOSE_ENABLED = false;
+  private static final boolean INFO_ENABLED = true;
+  private static final boolean DEBUG_ENABLED = true;
+  private static final boolean WARN_ENABLED = true;
 
   public static void verbose(Class<?> from, String message, Object... arguments) {
-    if (ENABLED && VERBOSE_ENABLED && isClassEnabled(from)) {
+    if (isLoggingEnabledFor(from) && VERBOSE_ENABLED) {
       log("VERB", from, message, arguments);
     }
   }
 
   public static void info(Class<?> from, String message, Object... arguments) {
-    if (ENABLED && INFO_ENABLED && isClassEnabled(from)) {
+    if (isLoggingEnabledFor(from) && INFO_ENABLED) {
       log("INFO", from, message, arguments);
     }
   }
 
   public static void debug(Class<?> from, String message, Object... arguments) {
-    if (ENABLED && DEBUG_ENABLED && isClassEnabled(from)) {
+    if (isLoggingEnabledFor(from) && DEBUG_ENABLED) {
       log("DBG", from, message, arguments);
     }
   }
 
   public static void warn(Class<?> from, String message, Object... arguments) {
-    if (ENABLED && WARN_ENABLED && isClassEnabled(from)) {
+    if (isLoggingEnabledFor(from) && WARN_ENABLED) {
       log("WARN", from, message, arguments);
     }
   }
 
-  private static boolean isClassEnabled(Class<?> clazz) {
-    return true;
+  public static boolean isLoggingEnabledFor(Class<?> clazz) {
+    return ENABLED;
   }
 
   synchronized private static void log(String kind, Class<?> from, String message, Object... args) {
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 9d43839..3560e2f 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -111,6 +111,14 @@
   private final boolean forceProguardCompatibility;
   private boolean tracingMainDex = false;
 
+  // If shrinking of the generated proto extension registry is enabled, then the Enqueuer
+  // won't trace the dead proto extensions fields. However, for the purpose of member value
+  // propagation, we should keep the dead proto extension fields in the program, such that
+  // member value propagation can find their definitions and the corresponding optimization
+  // info. This is handled by simply marking the dead proto extension types as live after the
+  // Enqueuer has finished. This way we don't actually trace these types.
+  private boolean markSkippedProtoExtensionTypesAsLive = false;
+
   private final AppInfoWithSubtyping appInfo;
   private final AppView<? extends AppInfoWithSubtyping> appView;
   private final InternalOptions options;
@@ -168,6 +176,14 @@
    */
   private final Set<DexType> liveTypes = Sets.newIdentityHashSet();
 
+  /**
+   * Set of proto extension types that are technically live, but which we have not traced because
+   * they are dead according to the generated extension registry shrinker.
+   *
+   * <p>Only used if {@link InternalOptions#enableGeneratedExtensionRegistryShrinking} is set.
+   */
+  private final Set<DexType> skippedProtoExtensionTypes = Sets.newIdentityHashSet();
+
   /** Set of annotation types that are instantiated. */
   private final SetWithReason<DexAnnotation> liveAnnotations =
       new SetWithReason<>(this::registerAnnotation);
@@ -287,6 +303,10 @@
     this.options = options;
   }
 
+  public void markSkippedProtoExtensionTypesAsLive(boolean value) {
+    markSkippedProtoExtensionTypesAsLive = value;
+  }
+
   private Set<DexField> staticFieldsWrittenOnlyInEnclosingStaticInitializer() {
     Set<DexField> result = Sets.newIdentityHashSet();
     fieldAccessInfoCollection.forEach(
@@ -609,9 +629,30 @@
       if (!registerFieldRead(field, currentMethod)) {
         return false;
       }
+
       if (Log.ENABLED) {
         Log.verbose(getClass(), "Register Sget `%s`.", field);
       }
+
+      DexEncodedField encodedField = appInfo.resolveField(field);
+      if (encodedField != null && encodedField.isProgramField(appView)) {
+        if (appView.options().enableGeneratedExtensionRegistryShrinking) {
+          // If it is a dead proto extension field, don't trace onwards.
+          boolean skipTracing =
+              appView.withGeneratedExtensionRegistryShrinker(
+                  shrinker ->
+                      shrinker.isDeadProtoExtensionField(
+                          encodedField.field, fieldAccessInfoCollection),
+                  false);
+          if (skipTracing) {
+            if (markSkippedProtoExtensionTypesAsLive) {
+              skippedProtoExtensionTypes.add(encodedField.field.holder);
+            }
+            return false;
+          }
+        }
+      }
+
       markStaticFieldAsLive(field, KeepReason.fieldReferencedIn(currentMethod));
       return true;
     }
@@ -621,12 +662,30 @@
       if (!registerFieldWrite(field, currentMethod)) {
         return false;
       }
+
       if (Log.ENABLED) {
         Log.verbose(getClass(), "Register Sput `%s`.", field);
       }
 
       DexEncodedField encodedField = appInfo.resolveField(field);
       if (encodedField != null && encodedField.isProgramField(appView)) {
+        if (appView.options().enableGeneratedExtensionRegistryShrinking) {
+          // If it is a dead proto extension field, don't trace onwards.
+          boolean skipTracing =
+              appView.withGeneratedExtensionRegistryShrinker(
+                  shrinker ->
+                      shrinker.isDeadProtoExtensionField(
+                          encodedField.field, fieldAccessInfoCollection),
+                  false);
+          if (skipTracing) {
+            if (markSkippedProtoExtensionTypesAsLive) {
+              skippedProtoExtensionTypes.add(encodedField.field.holder);
+            }
+            return false;
+          }
+        }
+
+        // If it is written outside of the <clinit> of its enclosing class, record it.
         boolean isWrittenOutsideEnclosingStaticInitializer =
             currentMethod.method.holder != encodedField.field.holder
                 || !currentMethod.isClassInitializer();
@@ -1564,6 +1623,14 @@
         (field, info) -> field != info.getField() || info == MISSING_FIELD_ACCESS_INFO);
     assert fieldAccessInfoCollection.verifyMappingIsOneToOne();
 
+    // Mark the proto extensions types that have not been traced as live if specified by the
+    // configuration. This enables the member value propagation to find the definition of the dead
+    // proto extension fields, and thereby optimize the corresponding static-get instructions (will
+    // always be null).
+    if (markSkippedProtoExtensionTypesAsLive) {
+      liveTypes.addAll(skippedProtoExtensionTypes);
+    }
+
     AppInfoWithLiveness appInfoWithLiveness =
         new AppInfoWithLiveness(
             appInfo,
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 0f6aace..8318f91 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -293,6 +293,9 @@
   public boolean enableLambdaMerging = false;
   // Flag to turn on/off desugaring in D8/R8.
   public boolean enableDesugaring = true;
+  // Flag to turn on/off GeneratedExtensionRegistry shrinking.
+  public boolean enableGeneratedExtensionRegistryShrinking =
+      System.getProperty("com.android.tools.r8.generatedExtensionRegistryShrinking") != null;
   // Flag to turn on/off JDK11+ nest-access control
   public boolean enableNestBasedAccessDesugaring = true;
   // Flag to turn on/off reduction of nest to improve class merging optimizations.
diff --git a/tools/run_on_app.py b/tools/run_on_app.py
index b8bd0ed..4c9a844 100755
--- a/tools/run_on_app.py
+++ b/tools/run_on_app.py
@@ -317,6 +317,8 @@
         args.extend(['--main-dex-rules', rules])
     if 'allow-type-errors' in values:
       extra_args.append('-Dcom.android.tools.r8.allowTypeErrors=1')
+    if 'proto-shrinking' in values:
+      extra_args.append('-Dcom.android.tools.r8.generatedExtensionRegistryShrinking=1')
 
   if not options.no_libraries and 'libraries' in values:
     for lib in values['libraries']:
diff --git a/tools/youtube_data.py b/tools/youtube_data.py
index f26af8d..94a97ce 100644
--- a/tools/youtube_data.py
+++ b/tools/youtube_data.py
@@ -131,6 +131,7 @@
       'pgconf': [
           '%s_proguard.config' % V14_19_PREFIX,
           '%s/proguardsettings/YouTubeRelease_proguard.config' % utils.THIRD_PARTY],
+      'proto-shrinking': 1,
       # Build for native multi dex, as Currently R8 cannot meet the main-dex
       # constraints.
       #'maindexrules' : [