Allow direct executors in cronet.

components/cronet/android/api/src/org/chromium/net/UrlRequest.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;
 
 import android.support.annotation.IntDef;
 import android.util.Log;
 import android.util.Pair;
 
@@ skipping 38 matching lines @@
         // Disable connection migration for just this request.
         boolean mDisableConnectionMigration;
         // Priority of request. Default is medium.
         @RequestPriority int mPriority = REQUEST_PRIORITY_MEDIUM;
         // Request reporting annotations. Avoid extra object creation if no annotations added.
         Collection<Object> mRequestAnnotations = Collections.emptyList();
         // If request is an upload, this provides the request body data.
         UploadDataProvider mUploadDataProvider;
         // Executor to call upload data provider back on.
         Executor mUploadDataProviderExecutor;
+        private boolean mAllowDirectExecutor = false;
 
         /**
          * Creates a builder for {@link UrlRequest} objects. All callbacks for
          * generated {@link UrlRequest} objects will be invoked 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.
          *
          * @param url {@link java.net.URL} for the generated requests.
          * @param callback callback object that gets invoked on different events.
@@ skipping 151 matching lines @@
             }
             if (mMethod == null) {
                 mMethod = "POST";
             }
             mUploadDataProvider = uploadDataProvider;
             mUploadDataProviderExecutor = executor;
             return this;
         }
 
         /**
+         * Marks that the executors this request will use to notify callbacks (for
+         * {@code UploadDataProvider}s and {@code UrlRequest.Callback}s) is intentionally performing
+         * inline execution, like Guava's directExecutor or
+         * {@link java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy}.
+         *
+         * <p><b>Warning:</b> This option makes it easy to accidentally block the network thread.
+         * It should not be used if your callbacks perform disk I/O, acquire locks, or call into
+         * other code you don't carefully control and audit.
+         */
+        public Builder allowDirectExecutor() {
+            mAllowDirectExecutor = true;
+            return this;
+        }
+
+        /**
          * Associates the annotation object with this request. May add more than one.
          * Passed through to a {@link RequestFinishedInfo.Listener},
          * see {@link RequestFinishedInfo#getAnnotations}.
          *
          * @param annotation an object to pass on to the {@link RequestFinishedInfo.Listener} with a
          * {@link RequestFinishedInfo}.
          * @return the builder to facilitate chaining.
          *
          * @hide as it's a prototype.
          */
@@ skipping 10 matching lines @@
 
         /**
          * Creates a {@link UrlRequest} using configuration within this
          * {@link Builder}. The returned {@code UrlRequest} can then be started
          * by calling {@link UrlRequest#start}.
          *
          * @return constructed {@link UrlRequest} using configuration within
          *         this {@link Builder}.
          */
         public UrlRequest build() {
             final UrlRequest request = mCronetEngine.createRequest(mUrl, mCallback, mExecutor,

[mef, 2016/08/30 16:29:44]

Can this executor be also just wrapped into DirectPreventingExecutor here
instead of passing flag down?

[Charles, 2016/08/30 20:11:06]

I didn't do that in this case because we pool the runnables that we're
submitting to the executor for reads here, and the checking for the native impl
is much simpler (just a check if we're on the network thread).

[mef, 2016/08/31 17:26:52]

Acknowledged.

-                    mPriority, mRequestAnnotations, mDisableCache, mDisableConnectionMigration);
+                    mPriority, mRequestAnnotations, mDisableCache, mDisableConnectionMigration,
+                    mAllowDirectExecutor);
             if (mMethod != null) {
                 request.setHttpMethod(mMethod);
             }
             for (Pair<String, String> header : mRequestHeaders) {
                 request.addHeader(header.first, header.second);
             }
             if (mUploadDataProvider != null) {
-                request.setUploadDataProvider(mUploadDataProvider, mUploadDataProviderExecutor);
+                if (mAllowDirectExecutor) {
+                    request.setUploadDataProvider(mUploadDataProvider, mUploadDataProviderExecutor);
+                } else {
+                    request.setUploadDataProvider(mUploadDataProvider,
+                            new DirectPreventingExecutor(mUploadDataProviderExecutor));
+                }
             }
             return request;
         }
     }
 
     /**
      * Users of Cronet extend this class to receive callbacks indicating the
      * progress of a {@link UrlRequest} being processed. An instance of this class
      * is passed in to {@link UrlRequest.Builder}'s constructor when
      * constructing the {@code UrlRequest}.
@@ skipping 398 matching lines @@
      *         the request's current status. {@code listener} will be invoked
      *         back on the {@link Executor} passed in when the request was
      *         created.
      */
     public void getStatus(final StatusListener listener);
 
     // Note:  There are deliberately no accessors for the results of the request
     // here. Having none removes any ambiguity over when they are populated,
     // particularly in the redirect case.
 }