Cronet API Refactoring

components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java

 // Copyright 2014 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.impl;
 
-import android.content.Context;
-import android.os.Build;
 import android.os.ConditionVariable;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Process;
 import android.util.Log;
 
 import org.chromium.base.ObserverList;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.NativeClassQualifiedName;
 import org.chromium.base.annotations.UsedByReflection;
 import org.chromium.net.BidirectionalStream;
-import org.chromium.net.CronetEngine;
 import org.chromium.net.EffectiveConnectionType;
+import org.chromium.net.ExperimentalBidirectionalStream;
 import org.chromium.net.NetworkQualityRttListener;
 import org.chromium.net.NetworkQualityThroughputListener;
 import org.chromium.net.RequestFinishedInfo;
 import org.chromium.net.UrlRequest;
 import org.chromium.net.urlconnection.CronetHttpURLConnection;
 import org.chromium.net.urlconnection.CronetURLStreamHandlerFactory;
 
 import java.net.Proxy;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLStreamHandlerFactory;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import javax.annotation.concurrent.GuardedBy;
 
 /**
  * CronetEngine using Chromium HTTP stack implementation.
  */
 @JNINamespace("cronet")
 @UsedByReflection("CronetEngine.java")
 @VisibleForTesting
-public class CronetUrlRequestContext extends CronetEngine {
+public class CronetUrlRequestContext extends CronetEngineBase {
     private static final int LOG_NONE = 3; // LOG(FATAL), no VLOG.
     private static final int LOG_DEBUG = -1; // LOG(FATAL...INFO), VLOG(1)
     private static final int LOG_VERBOSE = -2; // LOG(FATAL...INFO), VLOG(2)
     static final String LOG_TAG = "ChromiumNetwork";
 
     /**
      * Synchronize access to mUrlRequestContextAdapter and shutdown routine.
      */
     private final Object mLock = new Object();
     private final ConditionVariable mInitCompleted = new ConditionVariable(false);
@@ skipping 61 matching lines @@
     private boolean mIsLogging;
 
     /**
      * True if a NetLog observer that writes to disk with a bounded amount of space has been
      * activated by calling StartNetLogToDisk().
      */
     @GuardedBy("mLock")
     private boolean mNetLogToDisk;
 
     @UsedByReflection("CronetEngine.java")
-    public CronetUrlRequestContext(final CronetEngine.Builder builder) {
+    public CronetUrlRequestContext(final CronetEngineBuilderImpl builder) {
         CronetLibraryLoader.ensureInitialized(builder.getContext(), builder);
         nativeSetMinLogLevel(getLoggingLevel());
         synchronized (mLock) {
-            mUrlRequestContextAdapter = nativeCreateRequestContextAdapter(
-                    createNativeUrlRequestContextConfig(builder.getContext(), builder));
+            mUrlRequestContextAdapter =
+                    nativeCreateRequestContextAdapter(createNativeUrlRequestContextConfig(builder));
             if (mUrlRequestContextAdapter == 0) {
                 throw new NullPointerException("Context Adapter creation failed.");
             }
             mNetworkQualityEstimatorEnabled = builder.networkQualityEstimatorEnabled();
         }
 
         // Init native Chromium URLRequestContext on main UI thread.
         Runnable task = new Runnable() {
             @Override
             public void run() {
                 CronetLibraryLoader.ensureInitializedOnMainThread(builder.getContext());
                 synchronized (mLock) {
                     // mUrlRequestContextAdapter is guaranteed to exist until
                     // initialization on main and network threads completes and
                     // initNetworkThread is called back on network thread.
                     nativeInitRequestContextOnMainThread(mUrlRequestContextAdapter);
                 }
             }
         };
         // Run task immediately or post it to the UI thread.
         if (Looper.getMainLooper() == Looper.myLooper()) {
             task.run();
         } else {
             new Handler(Looper.getMainLooper()).post(task);
         }
     }
 
     @VisibleForTesting
-    public static long createNativeUrlRequestContextConfig(
-            final Context context, CronetEngine.Builder builder) {
+    public static long createNativeUrlRequestContextConfig(CronetEngineBuilderImpl builder) {
         final long urlRequestContextConfig = nativeCreateRequestContextConfig(
                 builder.getUserAgent(), builder.storagePath(), builder.quicEnabled(),
-                builder.getDefaultQuicUserAgentId(context), builder.http2Enabled(),
-                builder.sdchEnabled(), builder.dataReductionProxyKey(),
-                builder.dataReductionProxyPrimaryProxy(), builder.dataReductionProxyFallbackProxy(),
+                builder.getDefaultQuicUserAgentId(), builder.http2Enabled(), builder.sdchEnabled(),
+                builder.dataReductionProxyKey(), builder.dataReductionProxyPrimaryProxy(),
+                builder.dataReductionProxyFallbackProxy(),
                 builder.dataReductionProxySecureProxyCheckUrl(), builder.cacheDisabled(),
                 builder.httpCacheMode(), builder.httpCacheMaxSize(), builder.experimentalOptions(),
                 builder.mockCertVerifier(), builder.networkQualityEstimatorEnabled(),
                 builder.publicKeyPinningBypassForLocalTrustAnchorsEnabled(),
                 builder.certVerifierData());
-        for (Builder.QuicHint quicHint : builder.quicHints()) {
+        for (CronetEngineBuilderImpl.QuicHint quicHint : builder.quicHints()) {
             nativeAddQuicHint(urlRequestContextConfig, quicHint.mHost, quicHint.mPort,
                     quicHint.mAlternatePort);
         }
-        for (Builder.Pkp pkp : builder.publicKeyPins()) {
+        for (CronetEngineBuilderImpl.Pkp pkp : builder.publicKeyPins()) {
             nativeAddPkp(urlRequestContextConfig, pkp.mHost, pkp.mHashes, pkp.mIncludeSubdomains,
                     pkp.mExpirationDate.getTime());
         }
         return urlRequestContextConfig;
     }
 
     @Override
-    public UrlRequest createRequest(String url, UrlRequest.Callback callback, Executor executor,
+    public ExperimentalBidirectionalStream.Builder newBidirectionalStreamBuilder(
+            String url, BidirectionalStream.Callback callback, Executor executor) {
+        return new BidirectionalStreamBuilderImpl(url, callback, executor, this);
+    }
+
+    @Override
+    public UrlRequestBase createRequest(String url, UrlRequest.Callback callback, Executor executor,
             int priority, Collection<Object> requestAnnotations, boolean disableCache,
             boolean disableConnectionMigration, boolean allowDirectExecutor) {
         synchronized (mLock) {
             checkHaveAdapter();
             return new CronetUrlRequest(this, url, priority, callback, executor, requestAnnotations,
                     disableCache, disableConnectionMigration, allowDirectExecutor);
         }
     }
 
     @Override
-    public BidirectionalStream createBidirectionalStream(String url,
+    protected ExperimentalBidirectionalStream createBidirectionalStream(String url,
             BidirectionalStream.Callback callback, Executor executor, String httpMethod,
             List<Map.Entry<String, String>> requestHeaders,
-            @BidirectionalStream.Builder.StreamPriority int priority,
+            @BidirectionalStreamBuilderImpl.StreamPriority int priority,
             boolean delayRequestHeadersUntilFirstFlush, Collection<Object> requestAnnotations) {
         synchronized (mLock) {
             checkHaveAdapter();
             return new CronetBidirectionalStream(this, url, priority, callback, executor,
                     httpMethod, requestHeaders, delayRequestHeadersUntilFirstFlush,
                     requestAnnotations);
         }
     }
 
     @Override
-    public boolean isEnabled() {
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH;
-    }
-
-    @Override
     public String getVersionString() {
         return "Cronet/" + ImplVersion.getVersion();
     }
 
     @Override
     public void shutdown() {
         synchronized (mLock) {
             checkHaveAdapter();
             if (mActiveRequestCount.get() != 0) {
                 throw new IllegalStateException("Cannot shutdown with active requests.");
@@ skipping 407 matching lines @@
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeProvideRTTObservations(long nativePtr, boolean should);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeProvideThroughputObservations(long nativePtr, boolean should);
 
     public boolean isNetworkThread(Thread thread) {
         return thread == mNetworkThread;
     }
 }