| // Copyright 2012 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.content_public.browser; |
| |
| import org.chromium.base.CalledByNative; |
| import org.chromium.base.JNINamespace; |
| import org.chromium.content_public.common.Referrer; |
| import org.chromium.ui.base.PageTransition; |
| |
| import java.util.Locale; |
| import java.util.Map; |
| |
| /** |
| * Holds parameters for NavigationController.LoadUrl. Parameters should match |
| * counterparts in NavigationController::LoadURLParams, including default |
| * values. |
| */ |
| @JNINamespace("content") |
| public class LoadUrlParams { |
| // Should match NavigationController::LoadUrlType exactly. See comments |
| // there for proper usage. initializeConstants() checks that the values |
| // are correct. |
| public static final int LOAD_TYPE_DEFAULT = 0; |
| public static final int LOAD_TYPE_BROWSER_INITIATED_HTTP_POST = 1; |
| public static final int LOAD_TYPE_DATA = 2; |
| |
| // Should match NavigationController::UserAgentOverrideOption exactly. |
| // See comments there for proper usage. initializeConstants() checks that |
| // the values are correct. |
| public static final int UA_OVERRIDE_INHERIT = 0; |
| public static final int UA_OVERRIDE_FALSE = 1; |
| public static final int UA_OVERRIDE_TRUE = 2; |
| |
| // Fields with counterparts in NavigationController::LoadURLParams. |
| // Package private so that ContentViewCore.loadUrl can pass them down to |
| // native code. Should not be accessed directly anywhere else outside of |
| // this class. |
| String mUrl; |
| int mLoadUrlType; |
| int mTransitionType; |
| Referrer mReferrer; |
| private Map<String, String> mExtraHeaders; |
| private String mVerbatimHeaders; |
| int mUaOverrideOption; |
| byte[] mPostData; |
| String mBaseUrlForDataUrl; |
| String mVirtualUrlForDataUrl; |
| boolean mCanLoadLocalResources; |
| boolean mIsRendererInitiated; |
| |
| /** |
| * Creates an instance with default page transition type. |
| * @param url the url to be loaded |
| */ |
| public LoadUrlParams(String url) { |
| this(url, PageTransition.LINK); |
| } |
| |
| /** |
| * Creates an instance with the given page transition type. |
| * @param url the url to be loaded |
| * @param transitionType the PageTransitionType constant corresponding to the load |
| */ |
| public LoadUrlParams(String url, int transitionType) { |
| mUrl = url; |
| mTransitionType = transitionType; |
| |
| // Initialize other fields to defaults matching defaults of the native |
| // NavigationController::LoadUrlParams. |
| mLoadUrlType = LOAD_TYPE_DEFAULT; |
| mUaOverrideOption = UA_OVERRIDE_INHERIT; |
| mPostData = null; |
| mBaseUrlForDataUrl = null; |
| mVirtualUrlForDataUrl = null; |
| } |
| |
| /** |
| * Helper method to create a LoadUrlParams object for data url. |
| * @param data Data to be loaded. |
| * @param mimeType Mime type of the data. |
| * @param isBase64Encoded True if the data is encoded in Base 64 format. |
| */ |
| public static LoadUrlParams createLoadDataParams( |
| String data, String mimeType, boolean isBase64Encoded) { |
| return createLoadDataParams(data, mimeType, isBase64Encoded, null); |
| } |
| |
| /** |
| * Helper method to create a LoadUrlParams object for data url. |
| * @param data Data to be loaded. |
| * @param mimeType Mime type of the data. |
| * @param isBase64Encoded True if the data is encoded in Base 64 format. |
| * @param charset The character set for the data. Pass null if the mime type |
| * does not require a special charset. |
| */ |
| public static LoadUrlParams createLoadDataParams( |
| String data, String mimeType, boolean isBase64Encoded, String charset) { |
| StringBuilder dataUrl = new StringBuilder("data:"); |
| dataUrl.append(mimeType); |
| if (charset != null && !charset.isEmpty()) { |
| dataUrl.append(";charset=" + charset); |
| } |
| if (isBase64Encoded) { |
| dataUrl.append(";base64"); |
| } |
| dataUrl.append(","); |
| dataUrl.append(data); |
| |
| LoadUrlParams params = new LoadUrlParams(dataUrl.toString()); |
| params.setLoadType(LoadUrlParams.LOAD_TYPE_DATA); |
| params.setTransitionType(PageTransition.TYPED); |
| return params; |
| } |
| |
| /** |
| * Helper method to create a LoadUrlParams object for data url with base |
| * and virtual url. |
| * @param data Data to be loaded. |
| * @param mimeType Mime type of the data. |
| * @param isBase64Encoded True if the data is encoded in Base 64 format. |
| * @param baseUrl Base url of this data load. Note that for WebView compatibility, |
| * baseUrl and historyUrl are ignored if this is a data: url. |
| * Defaults to about:blank if null. |
| * @param historyUrl History url for this data load. Note that for WebView compatibility, |
| * this is ignored if baseUrl is a data: url. Defaults to about:blank |
| * if null. |
| */ |
| public static LoadUrlParams createLoadDataParamsWithBaseUrl( |
| String data, String mimeType, boolean isBase64Encoded, |
| String baseUrl, String historyUrl) { |
| return createLoadDataParamsWithBaseUrl(data, mimeType, isBase64Encoded, |
| baseUrl, historyUrl, null); |
| } |
| |
| /** |
| * Helper method to create a LoadUrlParams object for data url with base |
| * and virtual url. |
| * @param data Data to be loaded. |
| * @param mimeType Mime type of the data. |
| * @param isBase64Encoded True if the data is encoded in Base 64 format. |
| * @param baseUrl Base url of this data load. Note that for WebView compatibility, |
| * baseUrl and historyUrl are ignored if this is a data: url. |
| * Defaults to about:blank if null. |
| * @param historyUrl History url for this data load. Note that for WebView compatibility, |
| * this is ignored if baseUrl is a data: url. Defaults to about:blank |
| * if null. |
| * @param charset The character set for the data. Pass null if the mime type |
| * does not require a special charset. |
| */ |
| public static LoadUrlParams createLoadDataParamsWithBaseUrl( |
| String data, String mimeType, boolean isBase64Encoded, |
| String baseUrl, String historyUrl, String charset) { |
| LoadUrlParams params = createLoadDataParams(data, mimeType, isBase64Encoded, charset); |
| // For WebView compatibility, when the base URL has the 'data:' |
| // scheme, we treat it as a regular data URL load and skip setting |
| // baseUrl and historyUrl. |
| // TODO(joth): we should just append baseURL and historyURL here, and move the |
| // WebView specific transform up to a wrapper factory function in android_webview/. |
| if (baseUrl == null || !baseUrl.toLowerCase(Locale.US).startsWith("data:")) { |
| params.setBaseUrlForDataUrl(baseUrl != null ? baseUrl : "about:blank"); |
| params.setVirtualUrlForDataUrl(historyUrl != null ? historyUrl : "about:blank"); |
| } |
| return params; |
| } |
| |
| /** |
| * Helper method to create a LoadUrlParams object for an HTTP POST load. |
| * @param url URL of the load. |
| * @param postData Post data of the load. Can be null. |
| */ |
| public static LoadUrlParams createLoadHttpPostParams( |
| String url, byte[] postData) { |
| LoadUrlParams params = new LoadUrlParams(url); |
| params.setLoadType(LOAD_TYPE_BROWSER_INITIATED_HTTP_POST); |
| params.setTransitionType(PageTransition.TYPED); |
| params.setPostData(postData); |
| return params; |
| } |
| |
| /** |
| * Sets the url. |
| */ |
| public void setUrl(String url) { |
| mUrl = url; |
| } |
| |
| /** |
| * Return the url. |
| */ |
| public String getUrl() { |
| return mUrl; |
| } |
| |
| /** |
| * Return the base url for a data url, otherwise null. |
| */ |
| public String getBaseUrl() { |
| return mBaseUrlForDataUrl; |
| } |
| |
| /** |
| * Set load type of this load. Defaults to LOAD_TYPE_DEFAULT. |
| * @param loadType One of LOAD_TYPE static constants above. |
| */ |
| public void setLoadType(int loadType) { |
| mLoadUrlType = loadType; |
| } |
| |
| /** |
| * Set transition type of this load. Defaults to PageTransition.LINK. |
| * @param transitionType One of PAGE_TRANSITION static constants in ContentView. |
| */ |
| public void setTransitionType(int transitionType) { |
| mTransitionType = transitionType; |
| } |
| |
| /** |
| * Return the transition type. |
| */ |
| public int getTransitionType() { |
| return mTransitionType; |
| } |
| |
| /** |
| * @return the referrer of this load |
| */ |
| public void setReferrer(Referrer referrer) { |
| mReferrer = referrer; |
| } |
| |
| /** |
| * Sets the referrer of this load. |
| */ |
| public Referrer getReferrer() { |
| return mReferrer; |
| } |
| |
| /** |
| * Set extra headers for this load. |
| * @param extraHeaders Extra HTTP headers for this load. Note that these |
| * headers will never overwrite existing ones set by Chromium. |
| */ |
| public void setExtraHeaders(Map<String, String> extraHeaders) { |
| mExtraHeaders = extraHeaders; |
| } |
| |
| /** |
| * Return the extra headers as a map. |
| */ |
| public Map<String, String> getExtraHeaders() { |
| return mExtraHeaders; |
| } |
| |
| /** |
| * Return the extra headers as a single String separated by "\n", or null if no extra header is |
| * set. This form is suitable for passing to native |
| * NavigationController::LoadUrlParams::extra_headers. This will return the headers set in an |
| * exploded form through setExtraHeaders(). Embedders that work with extra headers in opaque |
| * collapsed form can use the setVerbatimHeaders() / getVerbatimHeaders() instead. |
| */ |
| public String getExtraHeadersString() { |
| return getExtraHeadersString("\n", false); |
| } |
| |
| /** |
| * Return the extra headers as a single String separated by "\r\n", or null if no extra header |
| * is set. This form is suitable for passing to native |
| * net::HttpRequestHeaders::AddHeadersFromString. |
| */ |
| public String getExtraHttpRequestHeadersString() { |
| return getExtraHeadersString("\r\n", true); |
| } |
| |
| private String getExtraHeadersString(String delimiter, boolean addTerminator) { |
| if (mExtraHeaders == null) return null; |
| |
| StringBuilder headerBuilder = new StringBuilder(); |
| for (Map.Entry<String, String> header : mExtraHeaders.entrySet()) { |
| if (headerBuilder.length() > 0) headerBuilder.append(delimiter); |
| |
| // Header name should be lower case. |
| headerBuilder.append(header.getKey().toLowerCase(Locale.US)); |
| headerBuilder.append(":"); |
| headerBuilder.append(header.getValue()); |
| } |
| if (addTerminator) |
| headerBuilder.append(delimiter); |
| |
| return headerBuilder.toString(); |
| } |
| |
| /** |
| * Sets the verbatim extra headers string. This is an alternative to storing the headers in |
| * a map (setExtraHeaders()) for the embedders that use collapsed headers strings. |
| */ |
| public void setVerbatimHeaders(String headers) { |
| mVerbatimHeaders = headers; |
| } |
| |
| /** |
| * @return the verbatim extra headers string |
| */ |
| public String getVerbatimHeaders() { |
| return mVerbatimHeaders; |
| } |
| |
| /** |
| * Set user agent override option of this load. Defaults to UA_OVERRIDE_INHERIT. |
| * @param uaOption One of UA_OVERRIDE static constants above. |
| */ |
| public void setOverrideUserAgent(int uaOption) { |
| mUaOverrideOption = uaOption; |
| } |
| |
| /** |
| * Get user agent override option of this load. Defaults to UA_OVERRIDE_INHERIT. |
| * @param uaOption One of UA_OVERRIDE static constants above. |
| */ |
| public int getUserAgentOverrideOption() { |
| return mUaOverrideOption; |
| } |
| |
| /** |
| * Set the post data of this load. This field is ignored unless load type is |
| * LOAD_TYPE_BROWSER_INITIATED_HTTP_POST. |
| * @param postData Post data for this http post load. |
| */ |
| public void setPostData(byte[] postData) { |
| mPostData = postData; |
| } |
| |
| /** |
| * @return the data to be sent through POST |
| */ |
| public byte[] getPostData() { |
| return mPostData; |
| } |
| |
| /** |
| * Set the base url for data load. It is used both to resolve relative URLs |
| * and when applying JavaScript's same origin policy. It is ignored unless |
| * load type is LOAD_TYPE_DATA. |
| * @param baseUrl The base url for this data load. |
| */ |
| public void setBaseUrlForDataUrl(String baseUrl) { |
| mBaseUrlForDataUrl = baseUrl; |
| } |
| |
| /** |
| * Get the virtual url for data load. It is the url displayed to the user. |
| * It is ignored unless load type is LOAD_TYPE_DATA. |
| * @return The virtual url for this data load. |
| */ |
| public String getVirtualUrlForDataUrl() { |
| return mVirtualUrlForDataUrl; |
| } |
| |
| /** |
| * Set the virtual url for data load. It is the url displayed to the user. |
| * It is ignored unless load type is LOAD_TYPE_DATA. |
| * @param virtualUrl The virtual url for this data load. |
| */ |
| public void setVirtualUrlForDataUrl(String virtualUrl) { |
| mVirtualUrlForDataUrl = virtualUrl; |
| } |
| |
| /** |
| * Set whether the load should be able to access local resources. This |
| * defaults to false. |
| */ |
| public void setCanLoadLocalResources(boolean canLoad) { |
| mCanLoadLocalResources = canLoad; |
| } |
| |
| /** |
| * Get whether the load should be able to access local resources. This |
| * defaults to false. |
| */ |
| public boolean getCanLoadLocalResources() { |
| return mCanLoadLocalResources; |
| } |
| |
| public int getLoadUrlType() { |
| return mLoadUrlType; |
| } |
| |
| /** |
| * @param rendererInitiated Whether or not this load was initiated from a renderer. |
| */ |
| public void setIsRendererInitiated(boolean rendererInitiated) { |
| mIsRendererInitiated = rendererInitiated; |
| } |
| |
| /** |
| * @return Whether or not this load was initiated from a renderer or not. |
| */ |
| public boolean getIsRendererInitiated() { |
| return mIsRendererInitiated; |
| } |
| |
| public boolean isBaseUrlDataScheme() { |
| // If there's no base url set, but this is a data load then |
| // treat the scheme as data:. |
| if (mBaseUrlForDataUrl == null && mLoadUrlType == LOAD_TYPE_DATA) { |
| return true; |
| } |
| return nativeIsDataScheme(mBaseUrlForDataUrl); |
| } |
| |
| @SuppressWarnings("unused") |
| @CalledByNative |
| private static void initializeConstants( |
| int loadTypeDefault, |
| int loadTypeBrowserInitiatedHttpPost, |
| int loadTypeData, |
| int uaOverrideInherit, |
| int uaOverrideFalse, |
| int uaOverrideTrue) { |
| assert LOAD_TYPE_DEFAULT == loadTypeDefault; |
| assert LOAD_TYPE_BROWSER_INITIATED_HTTP_POST == loadTypeBrowserInitiatedHttpPost; |
| assert LOAD_TYPE_DATA == loadTypeData; |
| assert UA_OVERRIDE_INHERIT == uaOverrideInherit; |
| assert UA_OVERRIDE_FALSE == uaOverrideFalse; |
| assert UA_OVERRIDE_TRUE == uaOverrideTrue; |
| } |
| |
| /** |
| * Parses |url| as a GURL on the native side, and |
| * returns true if it's scheme is data:. |
| */ |
| private static native boolean nativeIsDataScheme(String url); |
| } |