#20177

Committed 23 Feb 2026 03:46PM UTC coverage: 88.701% (-0.01%) from 88.714%

Build # #20177

Build Type

push

github

Committed by

web-flow

Commit Message

Trigger R8's ServiceLoader optimization

This simplifies R8 Full Mode's configuration when paired with R8
optimizations (which is made more difficult to avoid in AGP 9), as when
the optimization is triggered Full Mode will automatically keep the
constructor for the relevant classes.

android-interop-test doesn't currently enable R8 optimizations, so it
doesn't actually demonstrate the benefit, but I have manually confirmed
that enabling proguard-android-optimize.txt does cause the ServiceLoader
optimization in android-interop-test. Note that full mode is a separate
configuration and not necessary to get the ServiceLoader optimization.

Run Details

35461 of 39978 relevant lines covered (88.7%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

42.86

/../api/src/main/java/io/grpc/InternalServiceProviders.java

/*
 * Copyright 2017 The gRPC Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.grpc;

import com.google.common.annotations.VisibleForTesting;
import java.util.Iterator;
import java.util.List;
import java.util.ServiceLoader;

@Internal
public final class InternalServiceProviders {
  private InternalServiceProviders() {
  }

  /**
   * Accessor for method.
   */
  @Deprecated
  public static <T> List<T> loadAll(
      Class<T> klass,
      Iterable<Class<?>> hardCodedClasses,
      ClassLoader classLoader,
      PriorityAccessor<T> priorityAccessor) {
    return loadAll(
        klass,
        ServiceLoader.load(klass, classLoader).iterator(),
        () -> hardCodedClasses,
        priorityAccessor);
  }

  /**
   * Accessor for method.
   */
  public static <T> List<T> loadAll(
      Class<T> klass,
      Iterator<T> serviceLoader,
      Supplier<Iterable<Class<?>>> hardCodedClasses,
      PriorityAccessor<T> priorityAccessor) {
    return ServiceProviders.loadAll(klass, serviceLoader, hardCodedClasses::get, priorityAccessor);
  }

  /**
   * Accessor for method.
   */
  @VisibleForTesting
  public static <T> Iterable<T> getCandidatesViaServiceLoader(Class<T> klass, ClassLoader cl) {
    return ServiceProviders.getCandidatesViaServiceLoader(klass, cl);
  }

  /**
   * Accessor for method.
   */
  @VisibleForTesting
  public static <T> Iterable<T> getCandidatesViaHardCoded(
      Class<T> klass, Iterable<Class<?>> hardcoded) {
    return ServiceProviders.getCandidatesViaHardCoded(klass, hardcoded);
  }

  /**
   * Accessor for {@link ServiceProviders#isAndroid}.
   */
  public static boolean isAndroid(ClassLoader cl) {
    return ServiceProviders.isAndroid(cl);
  }

  public interface PriorityAccessor<T> extends ServiceProviders.PriorityAccessor<T> {}

  public interface Supplier<T> {
    T get();
  }
}

1	/*
2	* Copyright 2017 The gRPC Authors
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package io.grpc;
18
19	import com.google.common.annotations.VisibleForTesting;
20	import java.util.Iterator;
21	import java.util.List;
22	import java.util.ServiceLoader;
23
24	@Internal
25	public final class InternalServiceProviders {
26	private InternalServiceProviders() {
27	}
28
29	/**
30	* Accessor for method.
31	*/
32	@Deprecated
33	public static <T> List<T> loadAll(
34	Class<T> klass,
35	Iterable<Class<?>> hardCodedClasses,
36	ClassLoader classLoader,
37	PriorityAccessor<T> priorityAccessor) {
38	return loadAll(	×
39	klass,
40	ServiceLoader.load(klass, classLoader).iterator(),	×
41	() -> hardCodedClasses,	×
42	priorityAccessor);
43	}
44
45	/**
46	* Accessor for method.
47	*/
48	public static <T> List<T> loadAll(
49	Class<T> klass,
50	Iterator<T> serviceLoader,
51	Supplier<Iterable<Class<?>>> hardCodedClasses,
52	PriorityAccessor<T> priorityAccessor) {
53	return ServiceProviders.loadAll(klass, serviceLoader, hardCodedClasses::get, priorityAccessor);	1✔
54	}
55
56	/**
57	* Accessor for method.
58	*/
59	@VisibleForTesting
60	public static <T> Iterable<T> getCandidatesViaServiceLoader(Class<T> klass, ClassLoader cl) {
61	return ServiceProviders.getCandidatesViaServiceLoader(klass, cl);	1✔
62	}
63
64	/**
65	* Accessor for method.
66	*/
67	@VisibleForTesting
68	public static <T> Iterable<T> getCandidatesViaHardCoded(
69	Class<T> klass, Iterable<Class<?>> hardcoded) {
70	return ServiceProviders.getCandidatesViaHardCoded(klass, hardcoded);	×
71	}
72
73	/**
74	* Accessor for {@link ServiceProviders#isAndroid}.
75	*/
76	public static boolean isAndroid(ClassLoader cl) {
77	return ServiceProviders.isAndroid(cl);	1✔
78	}
79
80	public interface PriorityAccessor<T> extends ServiceProviders.PriorityAccessor<T> {}
81
82	public interface Supplier<T> {
83	T get();
84	}
85	}

grpc / grpc-java / #20177

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous