1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5package org.chromium.net;
6
7import org.json.JSONArray;
8import org.json.JSONException;
9import org.json.JSONObject;
10
11/**
12 * A config for HttpUrlRequestFactory, which allows runtime configuration of
13 * HttpUrlRequestFactory.
14 */
15public class HttpUrlRequestFactoryConfig {
16
17    /**
18     * Default config enables SPDY, QUIC, in memory http cache.
19     */
20    public HttpUrlRequestFactoryConfig() {
21        enableLegacyMode(false);
22        enableQUIC(false);
23        enableSPDY(true);
24        enableHttpCache(HttpCache.IN_MEMORY, 100 * 1024);
25    }
26
27    /**
28     * Override the name of the native library backing cronet.
29     */
30    public HttpUrlRequestFactoryConfig setLibraryName(String libName) {
31        return putString(UrlRequestContextConfig.NATIVE_LIBRARY_NAME, libName);
32    }
33
34    /**
35     * Create config from json serialized using @toString.
36     */
37    public HttpUrlRequestFactoryConfig(String json) throws JSONException {
38        mConfig = new JSONObject(json);
39    }
40
41    /**
42     * Boolean, use HttpUrlRequest-based implementation if true. All other
43     * keys are not applicable.
44     */
45    public HttpUrlRequestFactoryConfig enableLegacyMode(boolean value) {
46        return putBoolean(UrlRequestContextConfig.ENABLE_LEGACY_MODE, value);
47    }
48
49    boolean legacyMode() {
50        return mConfig.optBoolean(UrlRequestContextConfig.ENABLE_LEGACY_MODE);
51    }
52
53    /**
54     * Boolean, enable QUIC if true.
55     */
56    public HttpUrlRequestFactoryConfig enableQUIC(boolean value) {
57        return putBoolean(UrlRequestContextConfig.ENABLE_QUIC, value);
58    }
59
60    /**
61     * Boolean, enable SPDY if true.
62     */
63    public HttpUrlRequestFactoryConfig enableSPDY(boolean value) {
64        return putBoolean(UrlRequestContextConfig.ENABLE_SPDY, value);
65    }
66
67    String libraryName() {
68        return mConfig.optString(UrlRequestContextConfig.NATIVE_LIBRARY_NAME,
69                                 "cronet");
70    }
71
72    /**
73     * Enumeration, Disable or Enable Disk or Memory Cache and specify its
74     * maximum size in bytes.
75     */
76    public enum HttpCache { DISABLED, IN_MEMORY, DISK };
77    public HttpUrlRequestFactoryConfig enableHttpCache(HttpCache value,
78                                                       long maxSize) {
79        switch(value) {
80            case DISABLED:
81                return putString(UrlRequestContextConfig.HTTP_CACHE,
82                                 UrlRequestContextConfig.HTTP_CACHE_DISABLED);
83            case DISK:
84                putLong(UrlRequestContextConfig.HTTP_CACHE_MAX_SIZE, maxSize);
85                return putString(UrlRequestContextConfig.HTTP_CACHE,
86                                 UrlRequestContextConfig.HTTP_CACHE_DISK);
87            case IN_MEMORY:
88                putLong(UrlRequestContextConfig.HTTP_CACHE_MAX_SIZE, maxSize);
89                return putString(UrlRequestContextConfig.HTTP_CACHE,
90                                 UrlRequestContextConfig.HTTP_CACHE_MEMORY);
91        }
92        return this;
93    }
94
95    /**
96     * String, path to directory for HTTP Cache and Cookie Storage.
97     */
98    public HttpUrlRequestFactoryConfig setStoragePath(String value) {
99        return putString(UrlRequestContextConfig.STORAGE_PATH, value);
100    }
101
102    /**
103     * Explicitly mark |host| as supporting QUIC.
104     * Note that enableHttpCache(DISK) is needed to take advantage of 0-RTT
105     * connection establishment between sessions.
106     *
107     * @param host of the server that supports QUIC.
108     * @param port of the server that supports QUIC.
109     * @param alternatePort to use for QUIC.
110     */
111    public HttpUrlRequestFactoryConfig addQuicHint(String host,
112                                                   int port,
113                                                   int alternatePort) {
114        try {
115            JSONArray quicHints = mConfig.optJSONArray(
116                    UrlRequestContextConfig.QUIC_HINTS);
117            if (quicHints == null) {
118                quicHints = new JSONArray();
119                mConfig.put(UrlRequestContextConfig.QUIC_HINTS, quicHints);
120            }
121
122            JSONObject hint = new JSONObject();
123            hint.put(UrlRequestContextConfig.QUIC_HINT_HOST, host);
124            hint.put(UrlRequestContextConfig.QUIC_HINT_PORT, port);
125            hint.put(UrlRequestContextConfig.QUIC_HINT_ALT_PORT, alternatePort);
126            quicHints.put(hint);
127        } catch (JSONException e) {
128            ;
129        }
130        return this;
131    }
132
133    /**
134     * Get JSON string representation of the config.
135     */
136    public String toString() {
137        return mConfig.toString();
138    }
139
140    /**
141     * Sets a boolean value in the config. Returns a reference to the same
142     * config object, so you can chain put calls together.
143     */
144    private HttpUrlRequestFactoryConfig putBoolean(String key, boolean value) {
145        try {
146            mConfig.put(key, value);
147        } catch (JSONException e) {
148            ;
149        }
150        return this;
151    }
152
153    /**
154     * Sets a long value in the config. Returns a reference to the same
155     * config object, so you can chain put calls together.
156     */
157    private HttpUrlRequestFactoryConfig putLong(String key, long value)  {
158        try {
159            mConfig.put(key, value);
160        } catch (JSONException e) {
161            ;
162        }
163        return this;
164    }
165
166    /**
167     * Sets a string value in the config. Returns a reference to the same
168     * config object, so you can chain put calls together.
169     */
170    private HttpUrlRequestFactoryConfig putString(String key, String value) {
171        try {
172            mConfig.put(key, value);
173        } catch (JSONException e) {
174            ;
175        }
176        return this;
177    }
178
179    private JSONObject mConfig = new JSONObject();
180}
181