blob: cb5c45f9312a7065381e50787417441b120731a3 [file] [log] [blame]
// 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.
#include <stdint.h>
#include <map>
#include <string>
#include "base/memory/ref_counted.h"
#include "base/optional.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "content/common/content_export.h"
#include "content/common/content_security_policy/csp_disposition_enum.h"
#include "content/common/frame_message_enums.h"
#include "content/public/common/page_state.h"
#include "content/public/common/previews_state.h"
#include "content/public/common/referrer.h"
#include "content/public/common/request_context_type.h"
#include "net/url_request/redirect_info.h"
#include "services/network/public/cpp/resource_request_body.h"
#include "services/network/public/cpp/resource_response_info.h"
#include "third_party/WebKit/public/platform/WebMixedContentContextType.h"
#include "ui/base/page_transition_types.h"
#include "url/gurl.h"
#include "url/origin.h"
namespace content {
// PlzNavigate
// Struct keeping track of the Javascript SourceLocation that triggered the
// navigation. This is initialized based on information from Blink at the start
// of navigation, and passed back to Blink when the navigation commits.
struct CONTENT_EXPORT SourceLocation {
SourceLocation(const std::string& url,
unsigned int line_number,
unsigned int column_number);
std::string url;
unsigned int line_number;
unsigned int column_number;
// The following structures hold parameters used during a navigation. In
// particular they are used by FrameMsg_Navigate, FrameHostMsg_BeginNavigation,
// and mojom::FrameNavigationControl.
// Provided by the browser or the renderer -------------------------------------
// Used by all navigation IPCs.
struct CONTENT_EXPORT CommonNavigationParams {
const GURL& url,
const Referrer& referrer,
ui::PageTransition transition,
FrameMsg_Navigate_Type::Value navigation_type,
bool allow_download,
bool should_replace_current_entry,
base::TimeTicks ui_timestamp,
FrameMsg_UILoadMetricsReportType::Value report_type,
const GURL& base_url_for_data_url,
const GURL& history_url_for_data_url,
PreviewsState previews_state,
const base::TimeTicks& navigation_start,
std::string method,
const scoped_refptr<network::ResourceRequestBody>& post_data,
base::Optional<SourceLocation> source_location,
CSPDisposition should_check_main_world_csp,
bool started_from_context_menu,
bool has_user_gesture);
CommonNavigationParams(const CommonNavigationParams& other);
// The URL to navigate to.
// PlzNavigate: May be modified when the navigation is ready to commit.
GURL url;
// The URL to send in the "Referer" header field. Can be empty if there is
// no referrer.
Referrer referrer;
// The type of transition.
ui::PageTransition transition;
// Type of navigation.
FrameMsg_Navigate_Type::Value navigation_type;
// Allows the URL to be downloaded (true by default).
// Avoid downloading when in view-source mode.
bool allow_download;
// Informs the RenderView the pending navigation should replace the current
// history entry when it commits. This is used for cross-process redirects so
// the transferred navigation can recover the navigation state.
// PlzNavigate: this is used by client-side redirects to indicate that when
// the navigation commits, it should commit in the existing page.
bool should_replace_current_entry;
// Timestamp of the user input event that triggered this navigation. Empty if
// the navigation was not triggered by clicking on a link or by receiving an
// intent on Android.
base::TimeTicks ui_timestamp;
// The report type to be used when recording the metric using |ui_timestamp|.
FrameMsg_UILoadMetricsReportType::Value report_type;
// Base URL for use in Blink's SubstituteData.
// Is only used with data: URLs.
GURL base_url_for_data_url;
// History URL for use in Blink's SubstituteData.
// Is only used with data: URLs.
GURL history_url_for_data_url;
// Bitmask that has whether or not to request a Preview version of the
// document for various preview types or let the browser decide.
PreviewsState previews_state;
// The navigationStart time exposed through the Navigation Timing API to JS.
// If this is for a browser-initiated navigation, this can override the
// navigation_start value in Blink.
// PlzNavigate: For renderer initiated navigations, this will be set on the
// renderer side and sent with FrameHostMsg_BeginNavigation.
base::TimeTicks navigation_start;
// The request method: GET, POST, etc.
std::string method;
// Body of HTTP POST request.
scoped_refptr<network::ResourceRequestBody> post_data;
// PlzNavigate
// Information about the Javascript source for this navigation. Used for
// providing information in console error messages triggered by the
// navigation. If the navigation was not caused by Javascript, this should
// not be set.
base::Optional<SourceLocation> source_location;
// Whether or not the CSP of the main world should apply. When the navigation
// is initiated from a content script in an isolated world, the CSP defined
// in the main world should not apply.
// TODO(arthursonzogni): Instead of this boolean, the origin of the isolated
// world which has initiated the navigation should be passed.
// See
CSPDisposition should_check_main_world_csp;
// Whether or not this navigation was started from a context menu.
bool started_from_context_menu;
// True if the request was user initiated.
bool has_user_gesture;
// Provided by the browser -----------------------------------------------------
// PlzNavigate
// Timings collected in the browser during navigation for the
// Navigation Timing API. Sent to Blink in RequestNavigationParams when
// the navigation is ready to be committed.
struct CONTENT_EXPORT NavigationTiming {
base::TimeTicks redirect_start;
base::TimeTicks redirect_end;
base::TimeTicks fetch_start;
// Used by FrameMsg_Navigate. Holds the parameters needed by the renderer to
// start a browser-initiated navigation besides those in CommonNavigationParams.
// PlzNavigate: sent to the renderer to make it issue a stream request for a
// navigation that is ready to commit.
struct CONTENT_EXPORT RequestNavigationParams {
RequestNavigationParams(bool is_overriding_user_agent,
const std::vector<GURL>& redirects,
const GURL& original_url,
const std::string& original_method,
bool can_load_local_resources,
const PageState& page_state,
int nav_entry_id,
bool is_history_navigation_in_new_child,
std::map<std::string, bool> subframe_unique_names,
bool intended_as_new_entry,
int pending_history_list_offset,
int current_history_list_offset,
int current_history_list_length,
bool is_view_source,
bool should_clear_history_list);
RequestNavigationParams(const RequestNavigationParams& other);
// Whether or not the user agent override string should be used.
bool is_overriding_user_agent;
// Any redirect URLs that occurred before |url|. Useful for cross-process
// navigations; defaults to empty.
std::vector<GURL> redirects;
// The ResourceResponseInfos received during redirects.
std::vector<network::ResourceResponseInfo> redirect_response;
// PlzNavigate
// The RedirectInfos received during redirects.
std::vector<net::RedirectInfo> redirect_infos;
// PlzNavigate
// The content type from the request headers for POST requests.
std::string post_content_type;
// PlzNavigate
// The original URL & method for this navigation.
GURL original_url;
std::string original_method;
// Whether or not this url should be allowed to access local file://
// resources.
bool can_load_local_resources;
// Opaque history state (received by ViewHostMsg_UpdateState).
PageState page_state;
// For browser-initiated navigations, this is the unique id of the
// NavigationEntry being navigated to. (For renderer-initiated navigations it
// is 0.) If the load succeeds, then this nav_entry_id will be reflected in
// the resulting FrameHostMsg_DidCommitProvisionalLoad_Params.
int nav_entry_id;
// Whether this is a history navigation in a newly created child frame, in
// which case the browser process is instructing the renderer process to load
// a URL from a session history item. Defaults to false.
bool is_history_navigation_in_new_child;
// If this is a history navigation, this contains a map of frame unique names
// to |is_about_blank| for immediate children of the frame being navigated for
// which there are history items. The renderer process only needs to check
// with the browser process for newly created subframes that have these unique
// names (and only when not staying on about:blank).
// TODO(creis): Expand this to a data structure including corresponding
// same-process PageStates for the whole subtree in
std::map<std::string, bool> subframe_unique_names;
// For browser-initiated navigations, this is true if this is a new entry
// being navigated to. This is false otherwise. TODO(avi): Remove this when
// the pending entry situation is made sane and the browser keeps them around
// long enough to match them via nav_entry_id, above.
bool intended_as_new_entry;
// For history navigations, this is the offset in the history list of the
// pending load. For non-history navigations, this will be ignored.
int pending_history_list_offset;
// Where its current page contents reside in session history and the total
// size of the session history list.
int current_history_list_offset;
int current_history_list_length;
// Indicates whether the navigation is to a view-source:// scheme or not.
// It is a separate boolean as the view-source scheme is stripped from the
// URL before it is sent to the renderer process and the RenderFrame needs
// to be put in special view source mode.
bool is_view_source;
// Whether session history should be cleared. In that case, the RenderView
// needs to notify the browser that the clearing was succesful when the
// navigation commits.
bool should_clear_history_list;
// PlzNavigate
// Whether a ServiceWorkerProviderHost should be created for the window.
bool should_create_service_worker;
// PlzNavigate
// Timing of navigation events.
NavigationTiming navigation_timing;
// PlzNavigate
// The ServiceWorkerProviderHost ID used for navigations, if it was already
// created by the browser. Set to kInvalidServiceWorkerProviderId otherwise.
// This parameter is not used in the current navigation architecture, where
// it will always be equal to kInvalidServiceWorkerProviderId.
int service_worker_provider_id;
// PlzNavigate
// The AppCache host id to be used to identify this navigation.
int appcache_host_id;
#if defined(OS_ANDROID)
// The real content of the data: URL. Only used in Android WebView for
// implementing LoadDataWithBaseUrl API method to circumvent the restriction
// on the GURL max length in the IPC layer. Short data: URLs can still be
// passed in the |CommonNavigationParams::url| field.
std::string data_url_as_string;
// Helper struct keeping track in one place of all the parameters the browser
// needs to provide to the renderer.
struct NavigationParams {
NavigationParams(const CommonNavigationParams& common_params,
const RequestNavigationParams& request_params);
CommonNavigationParams common_params;
RequestNavigationParams request_params;
} // namespace content