[Cronet] Expose quic_user_agent_id and quic_prefer_aes config options.

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.content.Context;
 import android.support.annotation.IntDef;
 import android.support.annotation.Nullable;
 import android.util.Log;
@@ skipping 86 matching lines @@
         // See setters below for verbose descriptions.
         private final Context mContext;
         private final List<QuicHint> mQuicHints = new LinkedList<QuicHint>();
         private final List<Pkp> mPkps = new LinkedList<Pkp>();
         private String mUserAgent;
         private String mStoragePath;
         private boolean mLegacyModeEnabled;
         private LibraryLoader mLibraryLoader;
         private String mLibraryName;
         private boolean mQuicEnabled;
+        private String mQuicUserAgentId;
         private boolean mHttp2Enabled;
         private boolean mSdchEnabled;
         private String mDataReductionProxyKey;
         private String mDataReductionProxyPrimaryProxy;
         private String mDataReductionProxyFallbackProxy;
         private String mDataReductionProxySecureProxyCheckUrl;
         private boolean mDisableCache;
         private int mHttpCacheMode;
         private long mHttpCacheMaxSize;
         private String mExperimentalOptions;
         private long mMockCertVerifier;
 
         /**
          * Default config enables SPDY, disables QUIC, SDCH and HTTP cache.
          * @param context Android {@link Context} for engine to use.
          */
         public Builder(Context context) {
             mContext = context;
             setLibraryName("cronet");
             enableLegacyMode(false);
             enableQUIC(false);
             enableHTTP2(true);
             enableSDCH(false);
             enableHttpCache(HTTP_CACHE_DISABLED, 0);
         }
 
         /**
-         * Constructs a User-Agent string including Cronet version, and
-         * application name and version.
+         * Constructs a User-Agent string including application name and version,
+         * system build version, model and id, and Cronet version.
          *
          * @return User-Agent string.
          */
         public String getDefaultUserAgent() {
             return UserAgent.from(mContext);
         }
 
         /**
          * Overrides the User-Agent header for all requests. An explicitly
          * set User-Agent header (set using
@@ skipping 101 matching lines @@
         public Builder enableQUIC(boolean value) {
             mQuicEnabled = value;
             return this;
         }
 
         boolean quicEnabled() {
             return mQuicEnabled;
         }
 
         /**
+         * Constructs default QUIC User Agent Id string including application name
+         * and Cronet version.
+         *
+         * @return QUIC User Agent ID string.
+         */
+        public String getDefaultQuicUserAgentId() {

[xunjieli, 2016/02/04 14:00:06]

I feel that since we are in experimental stage here, we should avoid adding more
public APIs, which likely will be removed when QUIC in Cronet matures. Should we
consider passing the values using setExperimentalOptions? That way it is more
flexible in case we want to remove anything. Also will client be setting the UIC
User Agent themselves? If not, we can just use the default string.

+            return UserAgent.getQuicUserAgentIdFrom(mContext);
+        }
+
+        /**
+         * Overrides the UIC User Agent Id for all requests.
+         * @return the builder to facilitate chaining.
+         */
+        public Builder setQuicUserAgentId(String quicUserAgentId) {
+            mQuicUserAgentId = quicUserAgentId;
+            return this;
+        }
+
+        String getQuicUserAgentId() {
+            return mQuicUserAgentId;
+        }
+
+        /**
          * 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;
         }
 
@@ skipping 637 matching lines @@
      * @param builder builder to used for creating the CronetEngine instance.
      * @return the created CronetEngine instance.
      * @deprecated Use {@link CronetEngine.Builder}.
      */
     @Deprecated
     public static CronetEngine createContext(Builder builder) {
         CronetEngine cronetEngine = null;
         if (builder.getUserAgent() == null) {
             builder.setUserAgent(builder.getDefaultUserAgent());
         }
+        if (builder.quicEnabled() && builder.getQuicUserAgentId() == null) {
+            builder.setQuicUserAgentId(builder.getQuicUserAgentId());
+        }
         if (!builder.legacyMode()) {
             cronetEngine = createCronetEngine(builder);
         }
         if (cronetEngine == null) {
             cronetEngine = new JavaCronetEngine(builder.getUserAgent());
         }
         Log.i(TAG, "Using network stack: " + cronetEngine.getVersionString());
         return cronetEngine;
     }
 
@@ skipping 165 matching lines @@
      */
     @Deprecated
     public interface RequestFinishedListener { // TODO(klm): Add a convenience abstract class.
         /**
          * Invoked with request info.
          * @param requestInfo {@link UrlRequestInfo} for finished request.
          */
         void onRequestFinished(UrlRequestInfo requestInfo);
     }
 }