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 60 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));
             if (mUrlRequestContextAdapter == 0) {
                 throw new NullPointerException("Context Adapter creation failed.");
             }
             mNetworkQualityEstimatorEnabled = builder.networkQualityEstimatorEnabled();
         }
@@ skipping 14 matching lines @@
         // 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) {
+            final Context context, 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.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();
             boolean metricsCollectionEnabled = false;
             synchronized (mFinishedListenerLock) {
                 metricsCollectionEnabled = !mFinishedListenerList.isEmpty();
             }
             return new CronetUrlRequest(this, url, priority, callback, executor, requestAnnotations,
                     metricsCollectionEnabled, disableCache, disableConnectionMigration,
                     allowDirectExecutor);
         }
     }
 
+    /**
+     * Creates a {@link BidirectionalStream} object. {@code callback} methods will
+     * be invoked on {@code executor}. {@code executor} must not run
+     * tasks on the current thread to prevent blocking networking operations
+     * and causing exceptions during shutdown.
+     *
+     * @param url the URL for the stream
+     * @param callback the object whose methods get invoked upon different events
+     * @param executor the {@link Executor} on which all callbacks will be called
+     * @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 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.
+     */

[pauljensen, 2016/09/26 14:51:22]

Remove comment on @Override method

[kapishnikov, 2016/09/27 18:38:26]

Done.

     @Override
     public BidirectionalStream 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
@@ skipping 414 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;
     }
 }