[Cronet] Separate Cronet implementation and API by package name.

components/cronet/android/api/src/org/chromium/net/CronetEngine.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // 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 android.annotation.SuppressLint;
 import android.content.Context;
 import android.net.http.HttpResponseCache;
 import android.support.annotation.IntDef;
@@ skipping 43 matching lines @@
          * older devices.
          */
         public abstract static class LibraryLoader {
             /**
              * Loads the native library.
              * @param libName name of the library to load
              */
             public abstract void loadLibrary(String libName);
         }
 
-        // A hint that a host supports QUIC.
-        static class QuicHint {
+        /**
+         * A hint that a host supports QUIC.
+         * @hide only used by internal implementation.
+         */
+        public static class QuicHint {
             // The host.
-            final String mHost;
+            public final String mHost;
             // Port of the server that supports QUIC.
-            final int mPort;
+            public final int mPort;
             // Alternate protocol port.
-            final int mAlternatePort;
+            public final int mAlternatePort;
 
             QuicHint(String host, int port, int alternatePort) {
                 mHost = host;
                 mPort = port;
                 mAlternatePort = alternatePort;
             }
         }
 
-        // A public key pin.
-        static class Pkp {
+        /**
+         * A public key pin.
+         * @hide only used by internal implementation.
+         */
+        public static class Pkp {
             // Host to pin for.
-            final String mHost;
+            public final String mHost;
             // Array of SHA-256 hashes of keys.
-            final byte[][] mHashes;
+            public final byte[][] mHashes;
             // Should pin apply to subdomains?
-            final boolean mIncludeSubdomains;
+            public final boolean mIncludeSubdomains;
             // When the pin expires.
-            final Date mExpirationDate;
+            public final Date mExpirationDate;
 
             Pkp(String host, byte[][] hashes, boolean includeSubdomains, Date expirationDate) {
                 mHost = host;
                 mHashes = hashes;
                 mIncludeSubdomains = includeSubdomains;
                 mExpirationDate = expirationDate;
             }
         }
 
         private static final Pattern INVALID_PKP_HOST_NAME = Pattern.compile("^[0-9\\.]*$");
@@ skipping 57 matching lines @@
          * using this function.
          *
          * @param userAgent the User-Agent string to use for all requests.
          * @return the builder to facilitate chaining.
          */
         public Builder setUserAgent(String userAgent) {
             mUserAgent = userAgent;
             return this;
         }
 
-        String getUserAgent() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String getUserAgent() {
             return mUserAgent;
         }
 
         /**
          * Sets directory for HTTP Cache and Cookie Storage. The directory must
          * exist.
          * <p>
          * <b>NOTE:</b> Do not use the same storage directory with more than one
          * {@code CronetEngine} at a time. Access to the storage directory does
          * not support concurrent access by multiple {@code CronetEngine}s.
          *
          * @param value path to existing directory.
          * @return the builder to facilitate chaining.
          */
         public Builder setStoragePath(String value) {
             if (!new File(value).isDirectory()) {
                 throw new IllegalArgumentException(
                         "Storage path must be set to existing directory");
             }
             mStoragePath = value;
             return this;
         }
 
-        String storagePath() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String storagePath() {
             return mStoragePath;
         }
 
         /**
          * Sets whether the resulting {@link CronetEngine} uses an
          * implementation based on the system's
          * {@link java.net.HttpURLConnection} implementation, or if this is
          * only done as a backup if the native implementation fails to load.
          * Defaults to disabled.
          * @param value {@code true} makes the resulting {@link CronetEngine}
          *              use an implementation based on the system's
          *              {@link java.net.HttpURLConnection} implementation
          *              without trying to load the native implementation.
          *              {@code false} makes the resulting {@code CronetEngine}
          *              use the native implementation, or if that fails to load,
          *              falls back to an implementation based on the system's
          *              {@link java.net.HttpURLConnection} implementation.
          * @return the builder to facilitate chaining.
          * @deprecated Not supported by the new API.
          * @hide
          */
         @Deprecated
         public Builder enableLegacyMode(boolean value) {
             mLegacyModeEnabled = value;
             return this;
         }
 
-        boolean legacyMode() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public boolean legacyMode() {
             return mLegacyModeEnabled;
         }
 
         /**
          * Overrides the name of the native library backing Cronet.
          * @param libName the name of the native library backing Cronet.
          * @return the builder to facilitate chaining.
+         * @hide only used by internal implementation.
          */
-        Builder setLibraryName(String libName) {
+        public Builder setLibraryName(String libName) {
             mLibraryName = libName;
             return this;
         }
 
         /**
          * Sets a {@link LibraryLoader} to be used to load the native library.
          * If not set, the library will be loaded using {@link System#loadLibrary}.
          * @param loader {@code LibraryLoader} to be used to load the native library.
          * @return the builder to facilitate chaining.
          */
         public Builder setLibraryLoader(LibraryLoader loader) {
             mLibraryLoader = loader;
             return this;
         }
 
-        void loadLibrary() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public void loadLibrary() {
             if (mLibraryLoader == null) {
                 System.loadLibrary(mLibraryName);
             } else {
                 mLibraryLoader.loadLibrary(mLibraryName);
             }
         }
 
         /**
          * Sets whether <a href="https://www.chromium.org/quic">QUIC</a> protocol
          * is enabled. Defaults to disabled. If QUIC is enabled, then QUIC User Agent Id
          * containing application name and Cronet version is sent to the server.
          * @param value {@code true} to enable QUIC, {@code false} to disable.
          * @return the builder to facilitate chaining.
          */
         public Builder enableQUIC(boolean value) {
             mQuicEnabled = value;
             return this;
         }
 
-        boolean quicEnabled() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public boolean quicEnabled() {
             return mQuicEnabled;
         }
 
         /**
          * Constructs default QUIC User Agent Id string including application name
          * and Cronet version. Returns empty string if QUIC is not enabled.
          *
          * @param context Android {@link Context} to get package name from.
          * @return QUIC User Agent ID string.
+         * @hide only used by internal implementation.
          */
         // TODO(mef): remove |context| parameter when legacy ChromiumUrlRequestContext is removed.
-        String getDefaultQuicUserAgentId(Context context) {
+        public String getDefaultQuicUserAgentId(Context context) {
             return mQuicEnabled ? UserAgent.getQuicUserAgentIdFrom(context) : "";
         }
 
         /**
          * Sets whether <a href="https://tools.ietf.org/html/rfc7540">HTTP/2</a>
          * protocol is enabled. Defaults to enabled.
          * @param value {@code true} to enable HTTP/2, {@code false} to disable.
          * @return the builder to facilitate chaining.
          */
         public Builder enableHTTP2(boolean value) {
             mHttp2Enabled = value;
             return this;
         }
 
-        boolean http2Enabled() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public boolean http2Enabled() {
             return mHttp2Enabled;
         }
 
         /**
          * Sets whether
          * <a
          * href="https://lists.w3.org/Archives/Public/ietf-http-wg/2008JulSep/att-0441/Shared_Dictionary_Compression_over_HTTP.pdf">
          * SDCH</a> compression is enabled. Defaults to disabled.
          * @param value {@code true} to enable SDCH, {@code false} to disable.
          * @return the builder to facilitate chaining.
          */
         public Builder enableSDCH(boolean value) {
             mSdchEnabled = value;
             return this;
         }
 
-        boolean sdchEnabled() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public boolean sdchEnabled() {
             return mSdchEnabled;
         }
 
         /**
          * Enables
          * <a href="https://developer.chrome.com/multidevice/data-compression">Data
          * Reduction Proxy</a>. Defaults to disabled.
          * @param key key to use when authenticating with the proxy.
          * @return the builder to facilitate chaining.
          */
         public Builder enableDataReductionProxy(String key) {
             mDataReductionProxyKey = key;
             return this;
         }
 
-        String dataReductionProxyKey() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String dataReductionProxyKey() {
             return mDataReductionProxyKey;
         }
 
         /**
          * Overrides
          * <a href="https://developer.chrome.com/multidevice/data-compression">
          * Data Reduction Proxy</a> configuration parameters with a primary
          * proxy name, fallback proxy name, and a secure proxy check URL. Proxies
          * are specified as [scheme://]host[:port]. Used for testing.
          * @param primaryProxy the primary data reduction proxy to use.
          * @param fallbackProxy a fallback data reduction proxy to use.
          * @param secureProxyCheckUrl a URL to fetch to determine if using a secure
          * proxy is allowed.
          * @return the builder to facilitate chaining.
          * @hide as it's a prototype.
          */
         public Builder setDataReductionProxyOptions(
                 String primaryProxy, String fallbackProxy, String secureProxyCheckUrl) {
             if (primaryProxy.isEmpty() || fallbackProxy.isEmpty()
                     || secureProxyCheckUrl.isEmpty()) {
                 throw new IllegalArgumentException(
                         "Primary and fallback proxies and check url must be set");
             }
             mDataReductionProxyPrimaryProxy = primaryProxy;
             mDataReductionProxyFallbackProxy = fallbackProxy;
             mDataReductionProxySecureProxyCheckUrl = secureProxyCheckUrl;
             return this;
         }
 
-        String dataReductionProxyPrimaryProxy() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String dataReductionProxyPrimaryProxy() {
             return mDataReductionProxyPrimaryProxy;
         }
 
-        String dataReductionProxyFallbackProxy() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String dataReductionProxyFallbackProxy() {
             return mDataReductionProxyFallbackProxy;
         }
 
-        String dataReductionProxySecureProxyCheckUrl() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String dataReductionProxySecureProxyCheckUrl() {
             return mDataReductionProxySecureProxyCheckUrl;
         }
 
         /** @hide */
         @IntDef({
                 HTTP_CACHE_DISABLED, HTTP_CACHE_IN_MEMORY, HTTP_CACHE_DISK_NO_HTTP, HTTP_CACHE_DISK,
         })
         @Retention(RetentionPolicy.SOURCE)
         public @interface HttpCacheSetting {}
 
@@ skipping 56 matching lines @@
                     break;
                 case HTTP_CACHE_IN_MEMORY:
                     mHttpCacheMode = HttpCacheType.MEMORY;
                     break;
                 default:
                     throw new IllegalArgumentException("Unknown cache mode");
             }
             return this;
         }
 
-        boolean cacheDisabled() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public boolean cacheDisabled() {
             return mDisableCache;
         }
 
-        long httpCacheMaxSize() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public long httpCacheMaxSize() {
             return mHttpCacheMaxSize;
         }
 
-        int httpCacheMode() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public int httpCacheMode() {
             return mHttpCacheMode;
         }
 
         /**
          * Adds hint that {@code host} supports QUIC.
          * Note that {@link #enableHttpCache enableHttpCache}
          * ({@link #HTTP_CACHE_DISK}) is needed to take advantage of 0-RTT
          * connection establishment between sessions.
          *
          * @param host hostname of the server that supports QUIC.
          * @param port host of the server that supports QUIC.
          * @param alternatePort alternate port to use for QUIC.
          * @return the builder to facilitate chaining.
          */
         public Builder addQuicHint(String host, int port, int alternatePort) {
             if (host.contains("/")) {
                 throw new IllegalArgumentException("Illegal QUIC Hint Host: " + host);
             }
             mQuicHints.add(new QuicHint(host, port, alternatePort));
             return this;
         }
 
-        List<QuicHint> quicHints() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public List<QuicHint> quicHints() {
             return mQuicHints;
         }
 
         /**
          * <p>
          * Pins a set of public keys for a given host. By pinning a set of public keys,
          * {@code pinsSha256}, communication with {@code hostName} is required to
          * authenticate with a certificate with a public key from the set of pinned ones.
          * An app can pin the public key of the root certificate, any of the intermediate
          * certificates or the end-entry certificate. Authentication will fail and secure
@@ skipping 53 matching lines @@
             }
             // Add new element to PKP list.
             mPkps.add(new Pkp(idnHostName, hashes.toArray(new byte[hashes.size()][]),
                     includeSubdomains, expirationDate));
             return this;
         }
 
         /**
          * Returns list of public key pins.
          * @return list of public key pins.
+         * @hide only used by internal implementation.
          */
-        List<Pkp> publicKeyPins() {
+        public List<Pkp> publicKeyPins() {
             return mPkps;
         }
 
         /**
          * Enables or disables public key pinning bypass for local trust anchors. Disabling the
          * bypass for local trust anchors is highly discouraged since it may prohibit the app
          * from communicating with the pinned hosts. E.g., a user may want to send all traffic
          * through an SSL enabled proxy by changing the device proxy settings and adding the
          * proxy certificate to the list of local trust anchor. Disabling the bypass will most
          * likly prevent the app from sending any traffic to the pinned hosts. For more
          * information see 'How does key pinning interact with local proxies and filters?' at
          * https://www.chromium.org/Home/chromium-security/security-faq
          *
          * @param value {@code true} to enable the bypass, {@code false} to disable.
          * @return the builder to facilitate chaining.
          */
         public Builder enablePublicKeyPinningBypassForLocalTrustAnchors(boolean value) {
             mPublicKeyPinningBypassForLocalTrustAnchorsEnabled = value;
             return this;
         }
 
-        boolean publicKeyPinningBypassForLocalTrustAnchorsEnabled() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public boolean publicKeyPinningBypassForLocalTrustAnchorsEnabled() {
             return mPublicKeyPinningBypassForLocalTrustAnchorsEnabled;
         }
 
         /**
          * Checks whether a given string represents a valid host name for PKP and converts it
          * to ASCII Compatible Encoding representation according to RFC 1122, RFC 1123 and
          * RFC 3490. This method is more restrictive than required by RFC 7469. Thus, a host
          * that contains digits and the dot character only is considered invalid.
          *
          * Note: Currently Cronet doesn't have native implementation of host name validation that
@@ skipping 23 matching lines @@
          * Sets experimental options to be used in Cronet.
          *
          * @param options JSON formatted experimental options.
          * @return the builder to facilitate chaining.
          */
         public Builder setExperimentalOptions(String options) {
             mExperimentalOptions = options;
             return this;
         }
 
-        String experimentalOptions() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String experimentalOptions() {
             return mExperimentalOptions;
         }
 
         /**
          * Sets a native MockCertVerifier for testing. See
          * {@code MockCertVerifier.createMockCertVerifier} for a method that
          * can be used to create a MockCertVerifier.
          * @param mockCertVerifier pointer to native MockCertVerifier.
          * @return the builder to facilitate chaining.
          * @hide
          */
         @VisibleForTesting
         public Builder setMockCertVerifierForTesting(long mockCertVerifier) {
             mMockCertVerifier = mockCertVerifier;
             return this;
         }
 
-        long mockCertVerifier() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public long mockCertVerifier() {
             return mMockCertVerifier;
         }
 
         /**
          * Enables the network quality estimator, which collects and reports
          * measurements of round trip time (RTT) and downstream throughput at
          * various layers of the network stack. After enabling the estimator,
          * listeners of RTT and throughput can be added with
          * {@link #addRttListener} and {@link #addThroughputListener} and
          * removed with {@link #removeRttListener} and
          * {@link #removeThroughputListener}. The estimator uses memory and CPU
          * only when enabled.
          * @param value {@code true} to enable network quality estimator,
          *            {@code false} to disable.
          * @hide as it's a prototype.
          * @return the builder to facilitate chaining.
          */
         public Builder enableNetworkQualityEstimator(boolean value) {
             mNetworkQualityEstimatorEnabled = value;
             return this;
         }
 
         /**
          * @return true if the network quality estimator has been enabled for
          * this builder.
-         * @hide as it's a prototype.
+         * @hide as it's a prototype and only used by internal implementation.
          */
-        boolean networkQualityEstimatorEnabled() {
+        public boolean networkQualityEstimatorEnabled() {
             return mNetworkQualityEstimatorEnabled;
         }
 
         /**
          * Initializes CachingCertVerifier's cache with certVerifierData which has
          * the results of certificate verification.
          * @param certVerifierData a serialized representation of certificate
          *        verification results.
          * @return the builder to facilitate chaining.
          */
         public Builder setCertVerifierData(String certVerifierData) {
             mCertVerifierData = certVerifierData;
             return this;
         }
 
-        String certVerifierData() {
+        /**
+         * @hide only used by internal implementation.
+         */
+        public String certVerifierData() {
             return mCertVerifierData;
         }
 
         /**
          * Returns {@link Context} for builder.
          *
          * @return {@link Context} for builder.
+         * @hide only used by internal implementation.
          */
-        Context getContext() {
+        public Context getContext() {
             return mContext;
         }
 
         /**
          * Build a {@link CronetEngine} using this builder's configuration.
          * @return constructed {@link CronetEngine}.
          */
         public CronetEngine build() {
             if (getUserAgent() == null) {
                 setUserAgent(getDefaultUserAgent());
             }
             CronetEngine cronetEngine = null;
             if (!legacyMode()) {
                 cronetEngine = createCronetEngine(this);
             }
             if (cronetEngine == null) {
                 cronetEngine = new JavaCronetEngine(getUserAgent());
             }
             Log.i(TAG, "Using network stack: " + cronetEngine.getVersionString());
             // Clear MOCK_CERT_VERIFIER reference if there is any, since
             // the ownership has been transferred to the engine.
             mMockCertVerifier = 0;
             return cronetEngine;
         }
     }
 
     private static final String TAG = "UrlRequestFactory";
     private static final String CRONET_URL_REQUEST_CONTEXT =
-            "org.chromium.net.CronetUrlRequestContext";
+            "org.chromium.net.impl.CronetUrlRequestContext";
 
     /**
      * Creates a {@link UrlRequest} object. All callbacks will
      * be called on {@code executor}'s thread. {@code executor} must not run
      * tasks on the current thread to prevent blocking networking operations
      * and causing exceptions during shutdown. Request is given medium priority,
      * see {@link UrlRequest.Builder#REQUEST_PRIORITY_MEDIUM}. To specify other
      * priorities see {@link #createRequest(String, UrlRequest.Callback,
      * Executor, int priority)}.
      *
@@ skipping 72 matching lines @@
      * @param httpMethod the HTTP method to use for the stream
      * @param requestHeaders the list of request headers
      * @param priority priority of the stream which should be one of the
      *         {@link BidirectionalStream.Builder#STREAM_PRIORITY_IDLE STREAM_PRIORITY_*}
      *         values.
      * @param disableAutoFlush whether auto flush should be disabled
      * @param delayRequestHeadersUntilFirstFlush whether to delay sending request
      *         headers until flush() is called, and try to combine them
      *         with the next data frame.
      * @return a new stream.
+     * @hide only used by internal implementation.
      */
-    abstract BidirectionalStream createBidirectionalStream(String url,
+    public abstract BidirectionalStream createBidirectionalStream(String url,
             BidirectionalStream.Callback callback, Executor executor, String httpMethod,
             List<Map.Entry<String, String>> requestHeaders,
             @BidirectionalStream.Builder.StreamPriority int priority, boolean disableAutoFlush,
             boolean delayRequestHeadersUntilFirstFlush);
 
     /**
      * @return {@code true} if the engine is enabled.
+     * @hide only used by internal implementation.
      */
-    abstract boolean isEnabled();
+    public abstract boolean isEnabled();
 
     /**
      * @return a human-readable version string of the engine.
      */
     public abstract String getVersionString();
 
     /**
      * Shuts down the {@link CronetEngine} if there are no active requests,
      * otherwise throws an exception.
      *
@@ skipping 91 matching lines @@
 
     /**
      * Configures the network quality estimator for testing. This must be called
      * before round trip time and throughput listeners are added, and after the
      * network quality estimator has been enabled.
      * @param useLocalHostRequests include requests to localhost in estimates.
      * @param useSmallerResponses include small responses in throughput
      * estimates.
      * @hide as it's a prototype.
      */
-    abstract void configureNetworkQualityEstimatorForTesting(
+    public abstract void configureNetworkQualityEstimatorForTesting(
             boolean useLocalHostRequests, boolean useSmallerResponses);
 
     /**
      * Registers a listener that gets called whenever the network quality
      * estimator witnesses a sample round trip time. This must be called
      * after {@link #enableNetworkQualityEstimator}, and with throw an
      * exception otherwise. Round trip times may be recorded at various layers
      * of the network stack, including TCP, QUIC, and at the URL request layer.
      * The listener is called on the {@link java.util.concurrent.Executor} that
      * is passed to {@link #enableNetworkQualityEstimator}.
@@ skipping 147 matching lines @@
      * Information about a finished request. Passed to {@link RequestFinishedListener}.
      *
      * @hide as it's a prototype.
      */
     public static final class UrlRequestInfo {
         private final String mUrl;
         private final Collection<Object> mAnnotations;
         private final UrlRequestMetrics mMetrics;
         @Nullable private final UrlResponseInfo mResponseInfo;
 
-        UrlRequestInfo(String url, Collection<Object> annotations, UrlRequestMetrics metrics,
+        /**
+         * @hide only used by internal implementation.
+         */
+        public UrlRequestInfo(String url, Collection<Object> annotations, UrlRequestMetrics metrics,
                 @Nullable UrlResponseInfo responseInfo) {
             mUrl = url;
             mAnnotations = annotations;
             mMetrics = metrics;
             mResponseInfo = responseInfo;
         }
 
         /** Returns the request's original URL. */
         public String getUrl() {
             return mUrl;
@@ skipping 96 matching lines @@
      * @hide as it's a prototype.
      */
     public interface RequestFinishedListener {
         /**
          * Invoked with request info.
          * @param requestInfo {@link UrlRequestInfo} for finished request.
          */
         void onRequestFinished(UrlRequestInfo requestInfo);
     }
 }