| // Copyright 2014 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.impl; |
| |
| import static java.lang.Math.max; |
| import static org.chromium.net.UrlRequest.Builder.REQUEST_PRIORITY_IDLE; |
| import static org.chromium.net.UrlRequest.Builder.REQUEST_PRIORITY_LOWEST; |
| import static org.chromium.net.UrlRequest.Builder.REQUEST_PRIORITY_LOW; |
| import static org.chromium.net.UrlRequest.Builder.REQUEST_PRIORITY_MEDIUM; |
| import static org.chromium.net.UrlRequest.Builder.REQUEST_PRIORITY_HIGHEST; |
| |
| import android.os.Build; |
| |
| import androidx.annotation.RequiresApi; |
| import androidx.annotation.VisibleForTesting; |
| |
| import org.jni_zero.CalledByNative; |
| import org.jni_zero.JNINamespace; |
| import org.jni_zero.NativeClassQualifiedName; |
| import org.jni_zero.NativeMethods; |
| |
| import org.chromium.base.Log; |
| import org.chromium.net.CallbackException; |
| import org.chromium.net.CronetException; |
| import org.chromium.net.Idempotency; |
| import org.chromium.net.InlineExecutionProhibitedException; |
| import org.chromium.net.NetworkException; |
| import org.chromium.net.RequestFinishedInfo; |
| import org.chromium.net.RequestPriority; |
| import org.chromium.net.UploadDataProvider; |
| import org.chromium.net.UrlRequest; |
| import org.chromium.net.UrlResponseInfo.HeaderBlock; |
| import org.chromium.net.impl.CronetLogger.CronetTrafficInfo; |
| |
| import java.nio.ByteBuffer; |
| import java.time.Duration; |
| import java.util.AbstractMap; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.RejectedExecutionException; |
| |
| import javax.annotation.concurrent.GuardedBy; |
| |
| /** |
| * UrlRequest using Chromium HTTP stack implementation. Could be accessed from |
| * any thread on Executor. Cancel can be called from any thread. |
| * All @CallByNative methods are called on native network thread |
| * and post tasks with listener calls onto Executor. Upon return from listener |
| * callback native request adapter is called on executive thread and posts |
| * native tasks to native network thread. Because Cancel could be called from |
| * any thread it is protected by mUrlRequestAdapterLock. |
| */ |
| @JNINamespace("cronet") |
| @VisibleForTesting |
| public final class CronetUrlRequest extends UrlRequestBase { |
| private final boolean mAllowDirectExecutor; |
| |
| /* Native adapter object, owned by UrlRequest. */ |
| @GuardedBy("mUrlRequestAdapterLock") |
| private long mUrlRequestAdapter; |
| |
| @GuardedBy("mUrlRequestAdapterLock") |
| private boolean mStarted; |
| |
| @GuardedBy("mUrlRequestAdapterLock") |
| private boolean mWaitingOnRedirect; |
| |
| @GuardedBy("mUrlRequestAdapterLock") |
| private boolean mWaitingOnRead; |
| |
| /* |
| * Synchronize access to mUrlRequestAdapter, mStarted, mWaitingOnRedirect, |
| * and mWaitingOnRead. |
| */ |
| private final Object mUrlRequestAdapterLock = new Object(); |
| private final CronetUrlRequestContext mRequestContext; |
| private final Executor mExecutor; |
| |
| /* |
| * URL chain contains the URL currently being requested, and |
| * all URLs previously requested. New URLs are added before |
| * mCallback.onRedirectReceived is called. |
| */ |
| private final List<String> mUrlChain = new ArrayList<String>(); |
| |
| private final VersionSafeCallbacks.UrlRequestCallback mCallback; |
| private final String mInitialUrl; |
| private final int mPriority; |
| private final int mIdempotency; |
| private String mInitialMethod; |
| private final HeadersList mRequestHeaders = new HeadersList(); |
| private final Collection<Object> mRequestAnnotations; |
| private final boolean mDisableCache; |
| private final boolean mDisableConnectionMigration; |
| private final boolean mTrafficStatsTagSet; |
| private final int mTrafficStatsTag; |
| private final boolean mTrafficStatsUidSet; |
| private final int mTrafficStatsUid; |
| private final VersionSafeCallbacks.RequestFinishedInfoListener mRequestFinishedListener; |
| private final long mNetworkHandle; |
| private final int mCronetEngineId; |
| private final CronetLogger mLogger; |
| |
| private CronetUploadDataStream mUploadDataStream; |
| |
| private UrlResponseInfoImpl mResponseInfo; |
| |
| // These three should only be updated once with mUrlRequestAdapterLock held. They are read on |
| // UrlRequest.Callback's and RequestFinishedInfo.Listener's executors after the last update. |
| @RequestFinishedInfoImpl.FinishedReason private int mFinishedReason; |
| private CronetException mException; |
| private CronetMetrics mMetrics; |
| private boolean mQuicConnectionMigrationAttempted; |
| private boolean mQuicConnectionMigrationSuccessful; |
| |
| /* |
| * Listener callback is repeatedly invoked when each read is completed, so it |
| * is cached as a member variable. |
| */ |
| private OnReadCompletedRunnable mOnReadCompletedTask; |
| |
| @GuardedBy("mUrlRequestAdapterLock") |
| private Runnable mOnDestroyedCallbackForTesting; |
| |
| @VisibleForTesting |
| public static final class HeadersList extends ArrayList<Map.Entry<String, String>> {} |
| |
| private final class OnReadCompletedRunnable implements Runnable { |
| // Buffer passed back from current invocation of onReadCompleted. |
| ByteBuffer mByteBuffer; |
| |
| @Override |
| public void run() { |
| checkCallingThread(); |
| // Null out mByteBuffer, to pass buffer ownership to callback or release if done. |
| ByteBuffer buffer = mByteBuffer; |
| mByteBuffer = null; |
| |
| try { |
| synchronized (mUrlRequestAdapterLock) { |
| if (isDoneLocked()) { |
| return; |
| } |
| mWaitingOnRead = true; |
| } |
| mCallback.onReadCompleted(CronetUrlRequest.this, mResponseInfo, buffer); |
| } catch (Exception e) { |
| onCallbackException(e); |
| } |
| } |
| } |
| |
| CronetUrlRequest( |
| CronetUrlRequestContext requestContext, |
| String url, |
| int priority, |
| UrlRequest.Callback callback, |
| Executor executor, |
| Collection<Object> requestAnnotations, |
| boolean disableCache, |
| boolean disableConnectionMigration, |
| boolean allowDirectExecutor, |
| boolean trafficStatsTagSet, |
| int trafficStatsTag, |
| boolean trafficStatsUidSet, |
| int trafficStatsUid, |
| RequestFinishedInfo.Listener requestFinishedListener, |
| int idempotency, |
| long networkHandle) { |
| Objects.requireNonNull(url, "URL is required"); |
| Objects.requireNonNull(callback, "Listener is required"); |
| Objects.requireNonNull(executor, "Executor is required"); |
| |
| mAllowDirectExecutor = allowDirectExecutor; |
| mRequestContext = requestContext; |
| mCronetEngineId = requestContext.getCronetEngineId(); |
| mLogger = requestContext.getCronetLogger(); |
| mInitialUrl = url; |
| mUrlChain.add(url); |
| mPriority = convertRequestPriority(priority); |
| mCallback = new VersionSafeCallbacks.UrlRequestCallback(callback); |
| mExecutor = executor; |
| mRequestAnnotations = requestAnnotations; |
| mDisableCache = disableCache; |
| mDisableConnectionMigration = disableConnectionMigration; |
| mTrafficStatsTagSet = trafficStatsTagSet; |
| mTrafficStatsTag = trafficStatsTag; |
| mTrafficStatsUidSet = trafficStatsUidSet; |
| mTrafficStatsUid = trafficStatsUid; |
| mRequestFinishedListener = |
| requestFinishedListener != null |
| ? new VersionSafeCallbacks.RequestFinishedInfoListener( |
| requestFinishedListener) |
| : null; |
| mIdempotency = convertIdempotency(idempotency); |
| mNetworkHandle = networkHandle; |
| } |
| |
| @Override |
| public void setHttpMethod(String method) { |
| checkNotStarted(); |
| Objects.requireNonNull(method, "Method is required."); |
| mInitialMethod = method; |
| } |
| |
| @Override |
| public void addHeader(String header, String value) { |
| checkNotStarted(); |
| Objects.requireNonNull(header, "Invalid header name."); |
| Objects.requireNonNull(value, "Invalid header value."); |
| mRequestHeaders.add(new AbstractMap.SimpleImmutableEntry<String, String>(header, value)); |
| } |
| |
| @Override |
| public void setUploadDataProvider(UploadDataProvider uploadDataProvider, Executor executor) { |
| Objects.requireNonNull(uploadDataProvider, "Invalid UploadDataProvider."); |
| if (mInitialMethod == null) { |
| mInitialMethod = "POST"; |
| } |
| mUploadDataStream = new CronetUploadDataStream(uploadDataProvider, executor, this); |
| } |
| |
| @Override |
| public String getHttpMethod() { |
| return mInitialMethod; |
| } |
| |
| @Override |
| public boolean isDirectExecutorAllowed() { |
| return mAllowDirectExecutor; |
| } |
| |
| @Override |
| public boolean isCacheDisabled() { |
| return mDisableCache; |
| } |
| |
| @Override |
| public boolean hasTrafficStatsTag() { |
| return mTrafficStatsTagSet; |
| } |
| |
| @Override |
| public int getTrafficStatsTag() { |
| if (!hasTrafficStatsTag()) { |
| throw new IllegalStateException("TrafficStatsTag is not set"); |
| } |
| return mTrafficStatsTag; |
| } |
| |
| @Override |
| public boolean hasTrafficStatsUid() { |
| return mTrafficStatsUidSet; |
| } |
| |
| @Override |
| public int getTrafficStatsUid() { |
| if (!hasTrafficStatsUid()) { |
| throw new IllegalStateException("TrafficStatsUid is not set"); |
| } |
| return mTrafficStatsUid; |
| } |
| @Override |
| public int getPriority() { |
| switch (mPriority) { |
| case RequestPriority.IDLE: |
| return REQUEST_PRIORITY_IDLE; |
| case RequestPriority.LOWEST: |
| return REQUEST_PRIORITY_LOWEST; |
| case RequestPriority.LOW: |
| return REQUEST_PRIORITY_LOW; |
| case RequestPriority.MEDIUM: |
| return REQUEST_PRIORITY_MEDIUM; |
| case RequestPriority.HIGHEST: |
| return REQUEST_PRIORITY_HIGHEST; |
| default: |
| throw new IllegalStateException("Invalid request priority: " + mPriority); |
| } |
| } |
| |
| @Override |
| public HeaderBlock getHeaders() { |
| return new UrlResponseInfoImpl.HeaderBlockImpl(mRequestHeaders); |
| } |
| |
| @Override |
| public void start() { |
| synchronized (mUrlRequestAdapterLock) { |
| checkNotStarted(); |
| |
| try { |
| mUrlRequestAdapter = |
| CronetUrlRequestJni.get() |
| .createRequestAdapter( |
| CronetUrlRequest.this, |
| mRequestContext.getUrlRequestContextAdapter(), |
| mInitialUrl, |
| mPriority, |
| mDisableCache, |
| mDisableConnectionMigration, |
| mTrafficStatsTagSet, |
| mTrafficStatsTag, |
| mTrafficStatsUidSet, |
| mTrafficStatsUid, |
| mIdempotency, |
| mNetworkHandle); |
| mRequestContext.onRequestStarted(); |
| if (mInitialMethod != null) { |
| if (!CronetUrlRequestJni.get() |
| .setHttpMethod( |
| mUrlRequestAdapter, CronetUrlRequest.this, mInitialMethod)) { |
| throw new IllegalArgumentException("Invalid http method " + mInitialMethod); |
| } |
| } |
| |
| boolean hasContentType = false; |
| for (Map.Entry<String, String> header : mRequestHeaders) { |
| if (header.getKey().equalsIgnoreCase("Content-Type") |
| && !header.getValue().isEmpty()) { |
| hasContentType = true; |
| } |
| if (!CronetUrlRequestJni.get() |
| .addRequestHeader( |
| mUrlRequestAdapter, |
| CronetUrlRequest.this, |
| header.getKey(), |
| header.getValue())) { |
| throw new IllegalArgumentException( |
| "Invalid header with headername: " + header.getKey()); |
| } |
| } |
| if (mUploadDataStream != null) { |
| if (!hasContentType) { |
| throw new IllegalArgumentException( |
| "Requests with upload data must have a Content-Type."); |
| } |
| mStarted = true; |
| mUploadDataStream.postTaskToExecutor( |
| new Runnable() { |
| @Override |
| public void run() { |
| mUploadDataStream.initializeWithRequest(); |
| synchronized (mUrlRequestAdapterLock) { |
| if (isDoneLocked()) { |
| return; |
| } |
| mUploadDataStream.attachNativeAdapterToRequest( |
| mUrlRequestAdapter); |
| startInternalLocked(); |
| } |
| } |
| }); |
| return; |
| } |
| } catch (RuntimeException e) { |
| // If there's an exception, cleanup and then throw the exception to the caller. |
| // start() is synchronized so we do not acquire mUrlRequestAdapterLock here. |
| destroyRequestAdapterLocked(RequestFinishedInfo.FAILED); |
| mRequestContext.onRequestFinished(); |
| throw e; |
| } |
| mStarted = true; |
| startInternalLocked(); |
| } |
| } |
| |
| /* |
| * Starts fully configured request. Could execute on UploadDataProvider executor. |
| * Caller is expected to ensure that request isn't canceled and mUrlRequestAdapter is valid. |
| */ |
| @GuardedBy("mUrlRequestAdapterLock") |
| private void startInternalLocked() { |
| CronetUrlRequestJni.get().start(mUrlRequestAdapter, CronetUrlRequest.this); |
| } |
| |
| @Override |
| public void followRedirect() { |
| synchronized (mUrlRequestAdapterLock) { |
| if (!mWaitingOnRedirect) { |
| throw new IllegalStateException("No redirect to follow."); |
| } |
| mWaitingOnRedirect = false; |
| |
| if (isDoneLocked()) { |
| return; |
| } |
| |
| CronetUrlRequestJni.get() |
| .followDeferredRedirect(mUrlRequestAdapter, CronetUrlRequest.this); |
| } |
| } |
| |
| @Override |
| public void read(ByteBuffer buffer) { |
| Preconditions.checkHasRemaining(buffer); |
| Preconditions.checkDirect(buffer); |
| synchronized (mUrlRequestAdapterLock) { |
| if (!mWaitingOnRead) { |
| throw new IllegalStateException("Unexpected read attempt."); |
| } |
| mWaitingOnRead = false; |
| |
| if (isDoneLocked()) { |
| return; |
| } |
| |
| if (!CronetUrlRequestJni.get() |
| .readData( |
| mUrlRequestAdapter, |
| CronetUrlRequest.this, |
| buffer, |
| buffer.position(), |
| buffer.limit())) { |
| // Still waiting on read. This is just to have consistent |
| // behavior with the other error cases. |
| mWaitingOnRead = true; |
| throw new IllegalArgumentException("Unable to call native read"); |
| } |
| } |
| } |
| |
| @Override |
| public void cancel() { |
| synchronized (mUrlRequestAdapterLock) { |
| if (isDoneLocked() || !mStarted) { |
| return; |
| } |
| destroyRequestAdapterLocked(RequestFinishedInfo.CANCELED); |
| } |
| } |
| |
| @Override |
| public boolean isDone() { |
| synchronized (mUrlRequestAdapterLock) { |
| return isDoneLocked(); |
| } |
| } |
| |
| @GuardedBy("mUrlRequestAdapterLock") |
| private boolean isDoneLocked() { |
| return mStarted && mUrlRequestAdapter == 0; |
| } |
| |
| @Override |
| public void getStatus(UrlRequest.StatusListener unsafeListener) { |
| final VersionSafeCallbacks.UrlRequestStatusListener listener = |
| new VersionSafeCallbacks.UrlRequestStatusListener(unsafeListener); |
| synchronized (mUrlRequestAdapterLock) { |
| if (mUrlRequestAdapter != 0) { |
| CronetUrlRequestJni.get() |
| .getStatus(mUrlRequestAdapter, CronetUrlRequest.this, listener); |
| return; |
| } |
| } |
| Runnable task = |
| new Runnable() { |
| @Override |
| public void run() { |
| listener.onStatus(UrlRequest.Status.INVALID); |
| } |
| }; |
| postTaskToExecutor(task); |
| } |
| |
| public void setOnDestroyedCallbackForTesting(Runnable onDestroyedCallbackForTesting) { |
| synchronized (mUrlRequestAdapterLock) { |
| mOnDestroyedCallbackForTesting = onDestroyedCallbackForTesting; |
| } |
| } |
| |
| public void setOnDestroyedUploadCallbackForTesting( |
| Runnable onDestroyedUploadCallbackForTesting) { |
| mUploadDataStream.setOnDestroyedCallbackForTesting(onDestroyedUploadCallbackForTesting); |
| } |
| |
| public long getUrlRequestAdapterForTesting() { |
| synchronized (mUrlRequestAdapterLock) { |
| return mUrlRequestAdapter; |
| } |
| } |
| |
| /** |
| * Posts task to application Executor. Used for Listener callbacks |
| * and other tasks that should not be executed on network thread. |
| */ |
| private void postTaskToExecutor(Runnable task) { |
| try { |
| mExecutor.execute(task); |
| } catch (RejectedExecutionException failException) { |
| Log.e( |
| CronetUrlRequestContext.LOG_TAG, |
| "Exception posting task to executor", |
| failException); |
| // If posting a task throws an exception, then we fail the request. This exception could |
| // be permanent (executor shutdown), transient (AbortPolicy, or CallerRunsPolicy with |
| // direct execution not permitted), or caused by the runnables we submit if |
| // mUserExecutor is a direct executor and direct execution is not permitted. In the |
| // latter two cases, there is at least have a chance to inform the embedder of the |
| // request's failure, since failWithException does not enforce that onFailed() is not |
| // executed inline. |
| failWithException( |
| new CronetExceptionImpl("Exception posting task to executor", failException)); |
| } |
| } |
| |
| private static int convertRequestPriority(int priority) { |
| switch (priority) { |
| case Builder.REQUEST_PRIORITY_IDLE: |
| return RequestPriority.IDLE; |
| case Builder.REQUEST_PRIORITY_LOWEST: |
| return RequestPriority.LOWEST; |
| case Builder.REQUEST_PRIORITY_LOW: |
| return RequestPriority.LOW; |
| case Builder.REQUEST_PRIORITY_MEDIUM: |
| return RequestPriority.MEDIUM; |
| case Builder.REQUEST_PRIORITY_HIGHEST: |
| return RequestPriority.HIGHEST; |
| default: |
| return RequestPriority.MEDIUM; |
| } |
| } |
| |
| private static int convertIdempotency(int idempotency) { |
| switch (idempotency) { |
| case Builder.DEFAULT_IDEMPOTENCY: |
| return Idempotency.DEFAULT_IDEMPOTENCY; |
| case Builder.IDEMPOTENT: |
| return Idempotency.IDEMPOTENT; |
| case Builder.NOT_IDEMPOTENT: |
| return Idempotency.NOT_IDEMPOTENT; |
| default: |
| return Idempotency.DEFAULT_IDEMPOTENCY; |
| } |
| } |
| |
| /** |
| * Estimates the byte size of the headers in their on-wire format. |
| * We are not really interested in their specific size but something which is close enough. |
| */ |
| @VisibleForTesting |
| public static long estimateHeadersSizeInBytes(Map<String, List<String>> headers) { |
| if (headers == null) return 0; |
| |
| long responseHeaderSizeInBytes = 0; |
| for (Map.Entry<String, List<String>> entry : headers.entrySet()) { |
| String key = entry.getKey(); |
| if (key != null) responseHeaderSizeInBytes += key.length(); |
| if (entry.getValue() == null) continue; |
| |
| for (String content : entry.getValue()) { |
| responseHeaderSizeInBytes += content.length(); |
| } |
| } |
| return responseHeaderSizeInBytes; |
| } |
| |
| /** |
| * Estimates the byte size of the headers in their on-wire format. |
| * We are not really interested in their specific size but something which is close enough. |
| */ |
| @VisibleForTesting |
| public static long estimateHeadersSizeInBytes(HeadersList headers) { |
| if (headers == null) return 0; |
| long responseHeaderSizeInBytes = 0; |
| for (Map.Entry<String, String> entry : headers) { |
| String key = entry.getKey(); |
| if (key != null) responseHeaderSizeInBytes += key.length(); |
| String value = entry.getValue(); |
| if (value != null) responseHeaderSizeInBytes += entry.getValue().length(); |
| } |
| return responseHeaderSizeInBytes; |
| } |
| |
| private UrlResponseInfoImpl prepareResponseInfoOnNetworkThread( |
| int httpStatusCode, |
| String httpStatusText, |
| String[] headers, |
| boolean wasCached, |
| String negotiatedProtocol, |
| String proxyServer, |
| long receivedByteCount) { |
| HeadersList headersList = new HeadersList(); |
| for (int i = 0; i < headers.length; i += 2) { |
| headersList.add( |
| new AbstractMap.SimpleImmutableEntry<String, String>( |
| headers[i], headers[i + 1])); |
| } |
| return new UrlResponseInfoImpl( |
| new ArrayList<String>(mUrlChain), |
| httpStatusCode, |
| httpStatusText, |
| headersList, |
| wasCached, |
| negotiatedProtocol, |
| proxyServer, |
| receivedByteCount); |
| } |
| |
| private void checkNotStarted() { |
| synchronized (mUrlRequestAdapterLock) { |
| if (mStarted || isDoneLocked()) { |
| throw new IllegalStateException("Request is already started."); |
| } |
| } |
| } |
| |
| /** |
| * Helper method to set final status of CronetUrlRequest and clean up the |
| * native request adapter. |
| */ |
| @GuardedBy("mUrlRequestAdapterLock") |
| private void destroyRequestAdapterLocked( |
| @RequestFinishedInfoImpl.FinishedReason int finishedReason) { |
| assert mException == null || finishedReason == RequestFinishedInfo.FAILED; |
| mFinishedReason = finishedReason; |
| if (mUrlRequestAdapter == 0) { |
| return; |
| } |
| mRequestContext.onRequestDestroyed(); |
| // Posts a task to destroy the native adapter. |
| CronetUrlRequestJni.get() |
| .destroy( |
| mUrlRequestAdapter, |
| CronetUrlRequest.this, |
| finishedReason == RequestFinishedInfo.CANCELED); |
| mUrlRequestAdapter = 0; |
| } |
| |
| /** |
| * If callback method throws an exception, request gets canceled |
| * and exception is reported via onFailed listener callback. |
| * Only called on the Executor. |
| */ |
| private void onCallbackException(Exception e) { |
| CallbackException requestError = |
| new CallbackExceptionImpl("Exception received from UrlRequest.Callback", e); |
| Log.e(CronetUrlRequestContext.LOG_TAG, "Exception in CalledByNative method", e); |
| failWithException(requestError); |
| } |
| |
| /** Called when UploadDataProvider encounters an error. */ |
| void onUploadException(Throwable e) { |
| CallbackException uploadError = |
| new CallbackExceptionImpl("Exception received from UploadDataProvider", e); |
| Log.e(CronetUrlRequestContext.LOG_TAG, "Exception in upload method", e); |
| failWithException(uploadError); |
| } |
| |
| /** Fails the request with an exception on any thread. */ |
| private void failWithException(final CronetException exception) { |
| synchronized (mUrlRequestAdapterLock) { |
| if (isDoneLocked()) { |
| return; |
| } |
| assert mException == null; |
| mException = exception; |
| destroyRequestAdapterLocked(RequestFinishedInfo.FAILED); |
| } |
| // onFailed will be invoked from onNativeAdapterDestroyed() to ensure metrics collection. |
| } |
| |
| //////////////////////////////////////////////// |
| // Private methods called by the native code. |
| // Always called on network thread. |
| //////////////////////////////////////////////// |
| |
| /** |
| * Called before following redirects. The redirect will only be followed if |
| * {@link #followRedirect()} is called. If the redirect response has a body, it will be ignored. |
| * This will only be called between start and onResponseStarted. |
| * |
| * @param newLocation Location where request is redirected. |
| * @param httpStatusCode from redirect response |
| * @param receivedByteCount count of bytes received for redirect response |
| * @param headers an array of response headers with keys at the even indices |
| * followed by the corresponding values at the odd indices. |
| */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onRedirectReceived( |
| final String newLocation, |
| int httpStatusCode, |
| String httpStatusText, |
| String[] headers, |
| boolean wasCached, |
| String negotiatedProtocol, |
| String proxyServer, |
| long receivedByteCount) { |
| final UrlResponseInfoImpl responseInfo = |
| prepareResponseInfoOnNetworkThread( |
| httpStatusCode, |
| httpStatusText, |
| headers, |
| wasCached, |
| negotiatedProtocol, |
| proxyServer, |
| receivedByteCount); |
| |
| // Have to do this after creating responseInfo. |
| mUrlChain.add(newLocation); |
| |
| Runnable task = |
| new Runnable() { |
| @Override |
| public void run() { |
| checkCallingThread(); |
| synchronized (mUrlRequestAdapterLock) { |
| if (isDoneLocked()) { |
| return; |
| } |
| mWaitingOnRedirect = true; |
| } |
| |
| try { |
| mCallback.onRedirectReceived( |
| CronetUrlRequest.this, responseInfo, newLocation); |
| } catch (Exception e) { |
| onCallbackException(e); |
| } |
| } |
| }; |
| postTaskToExecutor(task); |
| } |
| |
| /** |
| * Called when the final set of headers, after all redirects, |
| * is received. Can only be called once for each request. |
| */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onResponseStarted( |
| int httpStatusCode, |
| String httpStatusText, |
| String[] headers, |
| boolean wasCached, |
| String negotiatedProtocol, |
| String proxyServer, |
| long receivedByteCount) { |
| mResponseInfo = |
| prepareResponseInfoOnNetworkThread( |
| httpStatusCode, |
| httpStatusText, |
| headers, |
| wasCached, |
| negotiatedProtocol, |
| proxyServer, |
| receivedByteCount); |
| Runnable task = |
| new Runnable() { |
| @Override |
| public void run() { |
| checkCallingThread(); |
| synchronized (mUrlRequestAdapterLock) { |
| if (isDoneLocked()) { |
| return; |
| } |
| mWaitingOnRead = true; |
| } |
| |
| try { |
| mCallback.onResponseStarted(CronetUrlRequest.this, mResponseInfo); |
| } catch (Exception e) { |
| onCallbackException(e); |
| } |
| } |
| }; |
| postTaskToExecutor(task); |
| } |
| |
| /** |
| * Called whenever data is received. The ByteBuffer remains |
| * valid only until listener callback. Or if the callback |
| * pauses the request, it remains valid until the request is resumed. |
| * Cancelling the request also invalidates the buffer. |
| * |
| * @param byteBuffer ByteBuffer containing received data, starting at |
| * initialPosition. Guaranteed to have at least one read byte. Its |
| * limit has not yet been updated to reflect the bytes read. |
| * @param bytesRead Number of bytes read. |
| * @param initialPosition Original position of byteBuffer when passed to |
| * read(). Used as a minimal check that the buffer hasn't been |
| * modified while reading from the network. |
| * @param initialLimit Original limit of byteBuffer when passed to |
| * read(). Used as a minimal check that the buffer hasn't been |
| * modified while reading from the network. |
| * @param receivedByteCount number of bytes received. |
| */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onReadCompleted( |
| final ByteBuffer byteBuffer, |
| int bytesRead, |
| int initialPosition, |
| int initialLimit, |
| long receivedByteCount) { |
| mResponseInfo.setReceivedByteCount(receivedByteCount); |
| if (byteBuffer.position() != initialPosition || byteBuffer.limit() != initialLimit) { |
| failWithException( |
| new CronetExceptionImpl("ByteBuffer modified externally during read", null)); |
| return; |
| } |
| if (mOnReadCompletedTask == null) { |
| mOnReadCompletedTask = new OnReadCompletedRunnable(); |
| } |
| byteBuffer.position(initialPosition + bytesRead); |
| mOnReadCompletedTask.mByteBuffer = byteBuffer; |
| postTaskToExecutor(mOnReadCompletedTask); |
| } |
| |
| /** |
| * Called when request is completed successfully, no callbacks will be |
| * called afterwards. |
| * |
| * @param receivedByteCount number of bytes received. |
| */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onSucceeded(long receivedByteCount) { |
| mResponseInfo.setReceivedByteCount(receivedByteCount); |
| Runnable task = |
| new Runnable() { |
| @Override |
| public void run() { |
| synchronized (mUrlRequestAdapterLock) { |
| if (isDoneLocked()) { |
| return; |
| } |
| // Destroy adapter first, so request context could be shut |
| // down from the listener. |
| destroyRequestAdapterLocked(RequestFinishedInfo.SUCCEEDED); |
| } |
| try { |
| mCallback.onSucceeded(CronetUrlRequest.this, mResponseInfo); |
| } catch (Exception e) { |
| Log.e( |
| CronetUrlRequestContext.LOG_TAG, |
| "Exception in onSucceeded method", |
| e); |
| } |
| maybeReportMetrics(); |
| } |
| }; |
| postTaskToExecutor(task); |
| } |
| |
| /** |
| * Called when error has occurred, no callbacks will be called afterwards. |
| * |
| * @param errorCode Error code represented by {@code UrlRequestError} that should be mapped |
| * to one of {@link NetworkException#ERROR_HOSTNAME_NOT_RESOLVED |
| * NetworkException.ERROR_*}. |
| * @param nativeError native net error code. |
| * @param errorString textual representation of the error code. |
| * @param receivedByteCount number of bytes received. |
| */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onError( |
| int errorCode, |
| int nativeError, |
| int nativeQuicError, |
| String errorString, |
| long receivedByteCount) { |
| if (mResponseInfo != null) { |
| mResponseInfo.setReceivedByteCount(receivedByteCount); |
| } |
| if (errorCode == NetworkException.ERROR_QUIC_PROTOCOL_FAILED |
| || errorCode == NetworkException.ERROR_NETWORK_CHANGED) { |
| failWithException( |
| new QuicExceptionImpl( |
| "Exception in CronetUrlRequest: " + errorString, |
| errorCode, |
| nativeError, |
| nativeQuicError)); |
| } else { |
| int javaError = mapUrlRequestErrorToApiErrorCode(errorCode); |
| failWithException( |
| new NetworkExceptionImpl( |
| "Exception in CronetUrlRequest: " + errorString, |
| javaError, |
| nativeError)); |
| } |
| } |
| |
| /** Called when request is canceled, no callbacks will be called afterwards. */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onCanceled() { |
| Runnable task = |
| new Runnable() { |
| @Override |
| public void run() { |
| try { |
| mCallback.onCanceled(CronetUrlRequest.this, mResponseInfo); |
| } catch (Exception e) { |
| Log.e( |
| CronetUrlRequestContext.LOG_TAG, |
| "Exception in onCanceled method", |
| e); |
| } |
| maybeReportMetrics(); |
| } |
| }; |
| postTaskToExecutor(task); |
| } |
| |
| /** |
| * Called by the native code when request status is fetched from the |
| * native stack. |
| */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onStatus( |
| final VersionSafeCallbacks.UrlRequestStatusListener listener, final int loadState) { |
| Runnable task = |
| new Runnable() { |
| @Override |
| public void run() { |
| listener.onStatus(convertLoadState(loadState)); |
| } |
| }; |
| postTaskToExecutor(task); |
| } |
| |
| /** |
| * Called by the native code on the network thread to report metrics. Happens before |
| * onSucceeded, onError and onCanceled. |
| */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onMetricsCollected( |
| long requestStartMs, |
| long dnsStartMs, |
| long dnsEndMs, |
| long connectStartMs, |
| long connectEndMs, |
| long sslStartMs, |
| long sslEndMs, |
| long sendingStartMs, |
| long sendingEndMs, |
| long pushStartMs, |
| long pushEndMs, |
| long responseStartMs, |
| long requestEndMs, |
| boolean socketReused, |
| long sentByteCount, |
| long receivedByteCount, |
| boolean quicConnectionMigrationAttempted, |
| boolean quicConnectionMigrationSuccessful) { |
| synchronized (mUrlRequestAdapterLock) { |
| if (mMetrics != null) { |
| throw new IllegalStateException("Metrics collection should only happen once."); |
| } |
| mMetrics = |
| new CronetMetrics( |
| requestStartMs, |
| dnsStartMs, |
| dnsEndMs, |
| connectStartMs, |
| connectEndMs, |
| sslStartMs, |
| sslEndMs, |
| sendingStartMs, |
| sendingEndMs, |
| pushStartMs, |
| pushEndMs, |
| responseStartMs, |
| requestEndMs, |
| socketReused, |
| sentByteCount, |
| receivedByteCount); |
| mQuicConnectionMigrationAttempted = quicConnectionMigrationAttempted; |
| mQuicConnectionMigrationSuccessful = quicConnectionMigrationSuccessful; |
| } |
| // Metrics are reported to RequestFinishedListener when the final UrlRequest.Callback has |
| // been invoked. |
| } |
| |
| /** Called when the native adapter is destroyed. */ |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private void onNativeAdapterDestroyed() { |
| synchronized (mUrlRequestAdapterLock) { |
| if (mOnDestroyedCallbackForTesting != null) { |
| mOnDestroyedCallbackForTesting.run(); |
| } |
| // mException is set when an error is encountered (in native code via onError or in |
| // Java code). If mException is not null, notify the mCallback and report metrics. |
| if (mException == null) { |
| return; |
| } |
| } |
| Runnable task = |
| new Runnable() { |
| @Override |
| public void run() { |
| try { |
| mCallback.onFailed(CronetUrlRequest.this, mResponseInfo, mException); |
| } catch (Exception e) { |
| Log.e( |
| CronetUrlRequestContext.LOG_TAG, |
| "Exception in onFailed method", |
| e); |
| } |
| maybeReportMetrics(); |
| } |
| }; |
| try { |
| mExecutor.execute(task); |
| } catch (RejectedExecutionException e) { |
| Log.e(CronetUrlRequestContext.LOG_TAG, "Exception posting task to executor", e); |
| } |
| } |
| |
| /** Enforces prohibition of direct execution. */ |
| void checkCallingThread() { |
| if (!mAllowDirectExecutor && mRequestContext.isNetworkThread(Thread.currentThread())) { |
| throw new InlineExecutionProhibitedException(); |
| } |
| } |
| |
| private int mapUrlRequestErrorToApiErrorCode(int errorCode) { |
| switch (errorCode) { |
| case UrlRequestError.HOSTNAME_NOT_RESOLVED: |
| return NetworkException.ERROR_HOSTNAME_NOT_RESOLVED; |
| case UrlRequestError.INTERNET_DISCONNECTED: |
| return NetworkException.ERROR_INTERNET_DISCONNECTED; |
| case UrlRequestError.NETWORK_CHANGED: |
| return NetworkException.ERROR_NETWORK_CHANGED; |
| case UrlRequestError.TIMED_OUT: |
| return NetworkException.ERROR_TIMED_OUT; |
| case UrlRequestError.CONNECTION_CLOSED: |
| return NetworkException.ERROR_CONNECTION_CLOSED; |
| case UrlRequestError.CONNECTION_TIMED_OUT: |
| return NetworkException.ERROR_CONNECTION_TIMED_OUT; |
| case UrlRequestError.CONNECTION_REFUSED: |
| return NetworkException.ERROR_CONNECTION_REFUSED; |
| case UrlRequestError.CONNECTION_RESET: |
| return NetworkException.ERROR_CONNECTION_RESET; |
| case UrlRequestError.ADDRESS_UNREACHABLE: |
| return NetworkException.ERROR_ADDRESS_UNREACHABLE; |
| case UrlRequestError.QUIC_PROTOCOL_FAILED: |
| return NetworkException.ERROR_QUIC_PROTOCOL_FAILED; |
| case UrlRequestError.OTHER: |
| return NetworkException.ERROR_OTHER; |
| default: |
| Log.e(CronetUrlRequestContext.LOG_TAG, "Unknown error code: " + errorCode); |
| return errorCode; |
| } |
| } |
| |
| /** |
| * Builds the {@link CronetTrafficInfo} associated to this request internal state. |
| * This helper methods makes strong assumptions about the state of the request. For this reason |
| * it should only be called within {@link CronetUrlRequest#maybeReportMetrics} where these |
| * assumptions are guaranteed to be true. |
| * @return the {@link CronetTrafficInfo} associated to this request internal state |
| */ |
| @RequiresApi(Build.VERSION_CODES.O) |
| private CronetTrafficInfo buildCronetTrafficInfo() { |
| assert mMetrics != null; |
| assert mRequestHeaders != null; |
| |
| // Most of the CronetTrafficInfo fields have similar names/semantics. To avoid bugs due to |
| // typos everything is final, this means that things have to initialized through an if/else. |
| final Map<String, List<String>> responseHeaders; |
| final String negotiatedProtocol; |
| final int httpStatusCode; |
| final boolean wasCached; |
| if (mResponseInfo != null) { |
| responseHeaders = mResponseInfo.getAllHeaders(); |
| negotiatedProtocol = mResponseInfo.getNegotiatedProtocol(); |
| httpStatusCode = mResponseInfo.getHttpStatusCode(); |
| wasCached = mResponseInfo.wasCached(); |
| } else { |
| responseHeaders = Collections.emptyMap(); |
| negotiatedProtocol = ""; |
| httpStatusCode = 0; |
| wasCached = false; |
| } |
| |
| // TODO(stefanoduo): A better approach might be keeping track of the total length of an |
| // upload and use that value as the request body size instead. |
| final long requestTotalSizeInBytes = mMetrics.getSentByteCount(); |
| final long requestHeaderSizeInBytes; |
| final long requestBodySizeInBytes; |
| // Cached responses might still need to be revalidated over the network before being served |
| // (from UrlResponseInfo#wasCached documentation). |
| if (wasCached && requestTotalSizeInBytes == 0) { |
| // Served from cache without the need to revalidate. |
| requestHeaderSizeInBytes = 0; |
| requestBodySizeInBytes = 0; |
| } else { |
| // Served from cache with the need to revalidate or served from the network directly. |
| requestHeaderSizeInBytes = estimateHeadersSizeInBytes(mRequestHeaders); |
| requestBodySizeInBytes = max(0, requestTotalSizeInBytes - requestHeaderSizeInBytes); |
| } |
| |
| final long responseTotalSizeInBytes = mMetrics.getReceivedByteCount(); |
| final long responseBodySizeInBytes; |
| final long responseHeaderSizeInBytes; |
| // Cached responses might still need to be revalidated over the network before being served |
| // (from UrlResponseInfo#wasCached documentation). |
| if (wasCached && responseTotalSizeInBytes == 0) { |
| // Served from cache without the need to revalidate. |
| responseBodySizeInBytes = 0; |
| responseHeaderSizeInBytes = 0; |
| } else { |
| // Served from cache with the need to revalidate or served from the network directly. |
| responseHeaderSizeInBytes = estimateHeadersSizeInBytes(responseHeaders); |
| responseBodySizeInBytes = max(0, responseTotalSizeInBytes - responseHeaderSizeInBytes); |
| } |
| |
| final Duration headersLatency; |
| if (mMetrics.getRequestStart() != null && mMetrics.getResponseStart() != null) { |
| headersLatency = |
| Duration.ofMillis( |
| mMetrics.getResponseStart().getTime() |
| - mMetrics.getRequestStart().getTime()); |
| } else { |
| headersLatency = Duration.ofSeconds(0); |
| } |
| |
| final Duration totalLatency; |
| if (mMetrics.getRequestStart() != null && mMetrics.getRequestEnd() != null) { |
| totalLatency = |
| Duration.ofMillis( |
| mMetrics.getRequestEnd().getTime() |
| - mMetrics.getRequestStart().getTime()); |
| } else { |
| totalLatency = Duration.ofSeconds(0); |
| } |
| |
| return new CronetTrafficInfo( |
| requestHeaderSizeInBytes, |
| requestBodySizeInBytes, |
| responseHeaderSizeInBytes, |
| responseBodySizeInBytes, |
| httpStatusCode, |
| headersLatency, |
| totalLatency, |
| negotiatedProtocol, |
| mQuicConnectionMigrationAttempted, |
| mQuicConnectionMigrationSuccessful); |
| } |
| |
| // Maybe report metrics. This method should only be called on Callback's executor thread and |
| // after Callback's onSucceeded, onFailed and onCanceled. |
| private void maybeReportMetrics() { |
| final RefCountDelegate inflightCallbackCount = |
| new RefCountDelegate(() -> mRequestContext.onRequestFinished()); |
| try { |
| if (mMetrics == null) return; |
| |
| if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { |
| try { |
| mLogger.logCronetTrafficInfo(mCronetEngineId, buildCronetTrafficInfo()); |
| } catch (RuntimeException e) { |
| // Handle any issue gracefully, we should never crash due failures while |
| // logging. |
| Log.e( |
| CronetUrlRequestContext.LOG_TAG, |
| "Error while trying to log CronetTrafficInfo: ", |
| e); |
| } |
| } |
| |
| final RequestFinishedInfo requestInfo = |
| new RequestFinishedInfoImpl( |
| mInitialUrl, |
| mRequestAnnotations, |
| mMetrics, |
| mFinishedReason, |
| mResponseInfo, |
| mException); |
| mRequestContext.reportRequestFinished(requestInfo, inflightCallbackCount); |
| if (mRequestFinishedListener != null) { |
| inflightCallbackCount.increment(); |
| try { |
| mRequestFinishedListener |
| .getExecutor() |
| .execute( |
| new Runnable() { |
| @Override |
| public void run() { |
| try { |
| mRequestFinishedListener.onRequestFinished( |
| requestInfo); |
| } catch (Exception e) { |
| Log.e( |
| CronetUrlRequestContext.LOG_TAG, |
| "Exception thrown from request" |
| + " finishedlistener", |
| e); |
| } finally { |
| inflightCallbackCount.decrement(); |
| } |
| } |
| }); |
| } catch (RejectedExecutionException failException) { |
| Log.e( |
| CronetUrlRequestContext.LOG_TAG, |
| "Exception posting task to executor", |
| failException); |
| inflightCallbackCount.decrement(); |
| } |
| } |
| } finally { |
| inflightCallbackCount.decrement(); |
| } |
| } |
| |
| // Native methods are implemented in cronet_url_request_adapter.cc. |
| @NativeMethods |
| interface Natives { |
| long createRequestAdapter( |
| CronetUrlRequest caller, |
| long urlRequestContextAdapter, |
| String url, |
| int priority, |
| boolean disableCache, |
| boolean disableConnectionMigration, |
| boolean trafficStatsTagSet, |
| int trafficStatsTag, |
| boolean trafficStatsUidSet, |
| int trafficStatsUid, |
| int idempotency, |
| long networkHandle); |
| |
| @NativeClassQualifiedName("CronetURLRequestAdapter") |
| boolean setHttpMethod(long nativePtr, CronetUrlRequest caller, String method); |
| |
| @NativeClassQualifiedName("CronetURLRequestAdapter") |
| boolean addRequestHeader( |
| long nativePtr, CronetUrlRequest caller, String name, String value); |
| |
| @NativeClassQualifiedName("CronetURLRequestAdapter") |
| void start(long nativePtr, CronetUrlRequest caller); |
| |
| @NativeClassQualifiedName("CronetURLRequestAdapter") |
| void followDeferredRedirect(long nativePtr, CronetUrlRequest caller); |
| |
| @NativeClassQualifiedName("CronetURLRequestAdapter") |
| boolean readData( |
| long nativePtr, |
| CronetUrlRequest caller, |
| ByteBuffer byteBuffer, |
| int position, |
| int capacity); |
| |
| @NativeClassQualifiedName("CronetURLRequestAdapter") |
| void destroy(long nativePtr, CronetUrlRequest caller, boolean sendOnCanceled); |
| |
| @NativeClassQualifiedName("CronetURLRequestAdapter") |
| void getStatus( |
| long nativePtr, |
| CronetUrlRequest caller, |
| VersionSafeCallbacks.UrlRequestStatusListener listener); |
| } |
| } |
