| // Copyright 2016 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| package org.chromium.net; |
| |
| import androidx.annotation.VisibleForTesting; |
| |
| import org.json.JSONException; |
| import org.json.JSONObject; |
| |
| import org.chromium.net.DnsOptions.StaleDnsOptions; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * An implementation of ICronetEngineBuilder which handles translation of configuration options to |
| * json-based experimental options, if necessary. |
| * |
| * <p>{@hide internal class} |
| */ |
| @VisibleForTesting |
| public final class ExperimentalOptionsTranslatingCronetEngineBuilder extends ICronetEngineBuilder { |
| private static final Set<Integer> SUPPORTED_OPTIONS = |
| Collections.unmodifiableSet( |
| new HashSet( |
| Arrays.asList( |
| ICronetEngineBuilder.CONNECTION_MIGRATION_OPTIONS, |
| ICronetEngineBuilder.DNS_OPTIONS, |
| ICronetEngineBuilder.QUIC_OPTIONS))); |
| |
| private JSONObject mParsedExperimentalOptions; |
| private final List<ExperimentalOptionsPatch> mExperimentalOptionsPatches = new ArrayList<>(); |
| |
| private final ICronetEngineBuilder mDelegate; |
| |
| ExperimentalOptionsTranslatingCronetEngineBuilder(ICronetEngineBuilder delegate) { |
| this.mDelegate = delegate; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setQuicOptions(QuicOptions options) { |
| // If the delegate builder supports enabling connection migration directly, just use it |
| if (mDelegate.getSupportedConfigOptions().contains(ICronetEngineBuilder.QUIC_OPTIONS)) { |
| mDelegate.setQuicOptions(options); |
| return this; |
| } |
| |
| // If not, we'll have to work around it by modifying the experimental options JSON. |
| mExperimentalOptionsPatches.add( |
| (experimentalOptions) -> { |
| JSONObject quicOptions = createDefaultIfAbsent(experimentalOptions, "QUIC"); |
| |
| // Note: using the experimental APIs always overwrites what's in the |
| // experimental JSON, even though "repeated" fields could in theory be |
| // additive. |
| if (!options.getQuicHostAllowlist().isEmpty()) { |
| quicOptions.put( |
| "host_whitelist", String.join(",", options.getQuicHostAllowlist())); |
| } |
| if (!options.getEnabledQuicVersions().isEmpty()) { |
| quicOptions.put( |
| "quic_version", String.join(",", options.getEnabledQuicVersions())); |
| } |
| if (!options.getConnectionOptions().isEmpty()) { |
| quicOptions.put( |
| "connection_options", |
| String.join(",", options.getConnectionOptions())); |
| } |
| if (!options.getClientConnectionOptions().isEmpty()) { |
| quicOptions.put( |
| "client_connection_options", |
| String.join(",", options.getClientConnectionOptions())); |
| } |
| if (!options.getExtraQuicheFlags().isEmpty()) { |
| quicOptions.put( |
| "set_quic_flags", String.join(",", options.getExtraQuicheFlags())); |
| } |
| |
| if (options.getInMemoryServerConfigsCacheSize() != null) { |
| quicOptions.put( |
| "max_server_configs_stored_in_properties", |
| options.getInMemoryServerConfigsCacheSize()); |
| } |
| |
| if (options.getHandshakeUserAgent() != null) { |
| quicOptions.put("user_agent_id", options.getHandshakeUserAgent()); |
| } |
| |
| if (options.getRetryWithoutAltSvcOnQuicErrors() != null) { |
| quicOptions.put( |
| "retry_without_alt_svc_on_quic_errors", |
| options.getRetryWithoutAltSvcOnQuicErrors()); |
| } |
| |
| if (options.getEnableTlsZeroRtt() != null) { |
| quicOptions.put("disable_tls_zero_rtt", !options.getEnableTlsZeroRtt()); |
| } |
| |
| if (options.getPreCryptoHandshakeIdleTimeoutSeconds() != null) { |
| quicOptions.put( |
| "max_idle_time_before_crypto_handshake_seconds", |
| options.getPreCryptoHandshakeIdleTimeoutSeconds()); |
| } |
| |
| if (options.getCryptoHandshakeTimeoutSeconds() != null) { |
| quicOptions.put( |
| "max_time_before_crypto_handshake_seconds", |
| options.getCryptoHandshakeTimeoutSeconds()); |
| } |
| |
| if (options.getIdleConnectionTimeoutSeconds() != null) { |
| quicOptions.put( |
| "idle_connection_timeout_seconds", |
| options.getIdleConnectionTimeoutSeconds()); |
| } |
| |
| if (options.getRetransmittableOnWireTimeoutMillis() != null) { |
| quicOptions.put( |
| "retransmittable_on_wire_timeout_milliseconds", |
| options.getRetransmittableOnWireTimeoutMillis()); |
| } |
| |
| if (options.getCloseSessionsOnIpChange() != null) { |
| quicOptions.put( |
| "close_sessions_on_ip_change", |
| options.getCloseSessionsOnIpChange()); |
| } |
| |
| if (options.getGoawaySessionsOnIpChange() != null) { |
| quicOptions.put( |
| "goaway_sessions_on_ip_change", |
| options.getGoawaySessionsOnIpChange()); |
| } |
| |
| if (options.getInitialBrokenServicePeriodSeconds() != null) { |
| quicOptions.put( |
| "initial_delay_for_broken_alternative_service_seconds", |
| options.getInitialBrokenServicePeriodSeconds()); |
| } |
| |
| if (options.getIncreaseBrokenServicePeriodExponentially() != null) { |
| quicOptions.put( |
| "exponential_backoff_on_initial_delay", |
| options.getIncreaseBrokenServicePeriodExponentially()); |
| } |
| |
| if (options.getDelayJobsWithAvailableSpdySession() != null) { |
| quicOptions.put( |
| "delay_main_job_with_available_spdy_session", |
| options.getDelayJobsWithAvailableSpdySession()); |
| } |
| }); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setDnsOptions(DnsOptions options) { |
| // If the delegate builder supports enabling connection migration directly, just use it |
| if (mDelegate.getSupportedConfigOptions().contains(ICronetEngineBuilder.DNS_OPTIONS)) { |
| mDelegate.setDnsOptions(options); |
| return this; |
| } |
| |
| // If not, we'll have to work around it by modifying the experimental options JSON. |
| mExperimentalOptionsPatches.add( |
| (experimentalOptions) -> { |
| JSONObject asyncDnsOptions = |
| createDefaultIfAbsent(experimentalOptions, "AsyncDNS"); |
| |
| if (options.getUseBuiltInDnsResolver() != null) { |
| asyncDnsOptions.put("enable", options.getUseBuiltInDnsResolver()); |
| } |
| |
| JSONObject staleDnsOptions = |
| createDefaultIfAbsent(experimentalOptions, "StaleDNS"); |
| |
| if (options.getEnableStaleDns() != null) { |
| staleDnsOptions.put("enable", options.getEnableStaleDns()); |
| } |
| |
| if (options.getPersistHostCache() != null) { |
| staleDnsOptions.put("persist_to_disk", options.getPersistHostCache()); |
| } |
| |
| if (options.getPersistHostCachePeriodMillis() != null) { |
| staleDnsOptions.put( |
| "persist_delay_ms", options.getPersistHostCachePeriodMillis()); |
| } |
| |
| if (options.getStaleDnsOptions() != null) { |
| StaleDnsOptions staleDnsOptionsJava = options.getStaleDnsOptions(); |
| |
| if (staleDnsOptionsJava.getAllowCrossNetworkUsage() != null) { |
| staleDnsOptions.put( |
| "allow_other_network", |
| staleDnsOptionsJava.getAllowCrossNetworkUsage()); |
| } |
| |
| if (staleDnsOptionsJava.getFreshLookupTimeoutMillis() != null) { |
| staleDnsOptions.put( |
| "delay_ms", staleDnsOptionsJava.getFreshLookupTimeoutMillis()); |
| } |
| |
| if (staleDnsOptionsJava.getUseStaleOnNameNotResolved() != null) { |
| staleDnsOptions.put( |
| "use_stale_on_name_not_resolved", |
| staleDnsOptionsJava.getUseStaleOnNameNotResolved()); |
| } |
| |
| if (staleDnsOptionsJava.getMaxExpiredDelayMillis() != null) { |
| staleDnsOptions.put( |
| "max_expired_time_ms", |
| staleDnsOptionsJava.getMaxExpiredDelayMillis()); |
| } |
| } |
| |
| JSONObject quicOptions = createDefaultIfAbsent(experimentalOptions, "QUIC"); |
| if (options.getPreestablishConnectionsToStaleDnsResults() != null) { |
| quicOptions.put( |
| "race_stale_dns_on_connection", |
| options.getPreestablishConnectionsToStaleDnsResults()); |
| } |
| }); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setConnectionMigrationOptions(ConnectionMigrationOptions options) { |
| // If the delegate builder supports enabling connection migration directly, just use it |
| if (mDelegate |
| .getSupportedConfigOptions() |
| .contains(ICronetEngineBuilder.CONNECTION_MIGRATION_OPTIONS)) { |
| mDelegate.setConnectionMigrationOptions(options); |
| return this; |
| } |
| |
| // If not, we'll have to work around it by modifying the experimental options JSON. |
| mExperimentalOptionsPatches.add( |
| (experimentalOptions) -> { |
| JSONObject quicOptions = createDefaultIfAbsent(experimentalOptions, "QUIC"); |
| |
| if (options.getEnableDefaultNetworkMigration() != null) { |
| quicOptions.put( |
| "migrate_sessions_on_network_change_v2", |
| options.getEnableDefaultNetworkMigration()); |
| } |
| if (options.getAllowServerMigration() != null) { |
| quicOptions.put( |
| "allow_server_migration", options.getAllowServerMigration()); |
| } |
| if (options.getMigrateIdleConnections() != null) { |
| quicOptions.put( |
| "migrate_idle_sessions", options.getMigrateIdleConnections()); |
| } |
| if (options.getIdleMigrationPeriodSeconds() != null) { |
| quicOptions.put( |
| "idle_session_migration_period_seconds", |
| options.getIdleMigrationPeriodSeconds()); |
| } |
| if (options.getRetryPreHandshakeErrorsOnAlternateNetwork() != null) { |
| quicOptions.put( |
| "retry_on_alternate_network_before_handshake", |
| options.getRetryPreHandshakeErrorsOnAlternateNetwork()); |
| } |
| if (options.getMaxTimeOnNonDefaultNetworkSeconds() != null) { |
| quicOptions.put( |
| "max_time_on_non_default_network_seconds", |
| options.getMaxTimeOnNonDefaultNetworkSeconds()); |
| } |
| if (options.getMaxPathDegradingEagerMigrationsCount() != null) { |
| quicOptions.put( |
| "max_migrations_to_non_default_network_on_path_degrading", |
| options.getMaxPathDegradingEagerMigrationsCount()); |
| } |
| if (options.getMaxWriteErrorEagerMigrationsCount() != null) { |
| quicOptions.put( |
| "max_migrations_to_non_default_network_on_write_error", |
| options.getMaxWriteErrorEagerMigrationsCount()); |
| } |
| if (options.getEnablePathDegradationMigration() != null) { |
| boolean pathDegradationValue = options.getEnablePathDegradationMigration(); |
| |
| boolean skipPortMigrationFlag = false; |
| |
| if (options.getAllowNonDefaultNetworkUsage() != null) { |
| boolean nonDefaultNetworkValue = |
| options.getAllowNonDefaultNetworkUsage(); |
| if (!pathDegradationValue && nonDefaultNetworkValue) { |
| // Misconfiguration which doesn't translate easily to the JSON flags |
| throw new IllegalArgumentException( |
| "Unable to turn on non-default network usage without path " |
| + "degradation migration!"); |
| } else if (pathDegradationValue && nonDefaultNetworkValue) { |
| // Both values being true results in the non-default network |
| // migration being enabled. |
| quicOptions.put("migrate_sessions_early_v2", true); |
| skipPortMigrationFlag = true; |
| } else { |
| quicOptions.put("migrate_sessions_early_v2", false); |
| } |
| } |
| |
| if (!skipPortMigrationFlag) { |
| quicOptions.put("allow_port_migration", pathDegradationValue); |
| } |
| } |
| }); |
| |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setExperimentalOptions(String options) { |
| if (options == null || options.isEmpty()) { |
| mParsedExperimentalOptions = null; |
| } else { |
| mParsedExperimentalOptions = parseExperimentalOptions(options); |
| } |
| return this; |
| } |
| |
| @Override |
| protected Set<Integer> getSupportedConfigOptions() { |
| return SUPPORTED_OPTIONS; |
| } |
| |
| @Override |
| public ExperimentalCronetEngine build() { |
| if (mParsedExperimentalOptions == null && mExperimentalOptionsPatches.isEmpty()) { |
| return mDelegate.build(); |
| } |
| |
| if (mParsedExperimentalOptions == null) { |
| mParsedExperimentalOptions = new JSONObject(); |
| } |
| |
| for (ExperimentalOptionsPatch patch : mExperimentalOptionsPatches) { |
| try { |
| patch.applyTo(mParsedExperimentalOptions); |
| } catch (JSONException e) { |
| throw new IllegalStateException("Unable to apply JSON patch!", e); |
| } |
| } |
| |
| mDelegate.setExperimentalOptions(mParsedExperimentalOptions.toString()); |
| return mDelegate.build(); |
| } |
| |
| private static JSONObject parseExperimentalOptions(String jsonString) { |
| try { |
| return new JSONObject(jsonString); |
| } catch (JSONException e) { |
| throw new IllegalArgumentException("Experimental options parsing failed", e); |
| } |
| } |
| |
| private static JSONObject createDefaultIfAbsent(JSONObject jsonObject, String key) { |
| JSONObject object = jsonObject.optJSONObject(key); |
| if (object == null) { |
| object = new JSONObject(); |
| try { |
| jsonObject.put(key, object); |
| } catch (JSONException e) { |
| throw new IllegalArgumentException( |
| "Failed adding a default object for key [" + key + "]", e); |
| } |
| } |
| |
| return object; |
| } |
| |
| @VisibleForTesting |
| public ICronetEngineBuilder getDelegate() { |
| return mDelegate; |
| } |
| |
| @FunctionalInterface |
| private interface ExperimentalOptionsPatch { |
| void applyTo(JSONObject experimentalOptions) throws JSONException; |
| } |
| |
| // Delegating-only methods |
| @Override |
| public ICronetEngineBuilder addPublicKeyPins( |
| String hostName, |
| Set<byte[]> pinsSha256, |
| boolean includeSubdomains, |
| Date expirationDate) { |
| mDelegate.addPublicKeyPins(hostName, pinsSha256, includeSubdomains, expirationDate); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder addQuicHint(String host, int port, int alternatePort) { |
| mDelegate.addQuicHint(host, port, alternatePort); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder enableHttp2(boolean value) { |
| mDelegate.enableHttp2(value); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder enableHttpCache(int cacheMode, long maxSize) { |
| mDelegate.enableHttpCache(cacheMode, maxSize); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder enablePublicKeyPinningBypassForLocalTrustAnchors(boolean value) { |
| mDelegate.enablePublicKeyPinningBypassForLocalTrustAnchors(value); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder enableQuic(boolean value) { |
| mDelegate.enableQuic(value); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder enableSdch(boolean value) { |
| mDelegate.enableSdch(value); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder enableBrotli(boolean value) { |
| mDelegate.enableBrotli(value); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setLibraryLoader(CronetEngine.Builder.LibraryLoader loader) { |
| mDelegate.setLibraryLoader(loader); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setStoragePath(String value) { |
| mDelegate.setStoragePath(value); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setUserAgent(String userAgent) { |
| mDelegate.setUserAgent(userAgent); |
| return this; |
| } |
| |
| @Override |
| public String getDefaultUserAgent() { |
| return mDelegate.getDefaultUserAgent(); |
| } |
| |
| @Override |
| public ICronetEngineBuilder enableNetworkQualityEstimator(boolean value) { |
| mDelegate.enableNetworkQualityEstimator(value); |
| return this; |
| } |
| |
| @Override |
| public ICronetEngineBuilder setThreadPriority(int priority) { |
| mDelegate.setThreadPriority(priority); |
| return this; |
| } |
| } |
