blob: aaa1d2e37a50302003a7a6ff35b40150daaa39ca [file] [log] [blame]
// Copyright 2013 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 <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/containers/flat_set.h"
#include "base/feature_list.h"
#include "build/build_config.h"
#include "content/common/content_export.h"
#include "content/public/browser/page_visibility_state.h"
#include "content/public/common/console_message_level.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.h"
#include "services/network/public/mojom/url_loader_factory.mojom.h"
#include "third_party/blink/public/common/frame/sandbox_flags.h"
#include "third_party/blink/public/mojom/loader/pause_subresource_loading_handle.mojom.h"
#include "third_party/blink/public/platform/web_sudden_termination_disabler_type.h"
#include "ui/accessibility/ax_tree_id.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/native_widget_types.h"
#include "url/gurl.h"
#include "url/origin.h"
namespace blink {
class AssociatedInterfaceProvider;
struct WebMediaPlayerAction;
namespace mojom {
enum class FeaturePolicyFeature;
} // namespace mojom
} // namespace blink
namespace base {
class UnguessableToken;
class Value;
namespace features {
CONTENT_EXPORT extern const base::Feature kCrashReporting;
} // namespace features
namespace resource_coordinator {
class FrameResourceCoordinator;
namespace service_manager {
class InterfaceProvider;
namespace ui {
struct AXActionData;
namespace content {
class RenderProcessHost;
class RenderViewHost;
class RenderWidgetHostView;
class SiteInstance;
// The interface provides a communication conduit with a frame in the renderer.
class CONTENT_EXPORT RenderFrameHost : public IPC::Listener,
public IPC::Sender {
// Constant used to denote that a lookup of a FrameTreeNode ID has failed.
static const int kNoFrameTreeNodeId = -1;
// Returns the RenderFrameHost given its ID and the ID of its render process.
// Returns nullptr if the IDs do not correspond to a live RenderFrameHost.
static RenderFrameHost* FromID(int render_process_id, int render_frame_id);
#if defined(OS_ANDROID) || defined(OS_FUCHSIA)
// Globally allows for injecting JavaScript into the main world. This feature
// is present only to support Android WebView and Fuchsia web.Contexts, and
// must not be used in other configurations.
static void AllowInjectingJavaScript();
// Returns a RenderFrameHost given its accessibility tree ID.
static RenderFrameHost* FromAXTreeID(ui::AXTreeID ax_tree_id);
// Returns the FrameTreeNode ID corresponding to the specified |process_id|
// and |routing_id|. This routing ID pair may represent a placeholder for
// frame that is currently rendered in a different process than |process_id|.
static int GetFrameTreeNodeIdForRoutingId(int process_id, int routing_id);
// Returns the RenderFrameHost corresponding to the |placeholder_routing_id|
// in the given |render_process_id|. The returned RenderFrameHost will always
// be in a different process. It may be null if the placeholder is not found
// in the given process, which may happen if the frame was recently deleted
// or swapped to |render_process_id| itself.
static RenderFrameHost* FromPlaceholderId(int render_process_id,
int placeholder_routing_id);
~RenderFrameHost() override {}
// Returns the route id for this frame.
virtual int GetRoutingID() = 0;
// Returns the accessibility tree ID for this RenderFrameHost.
virtual ui::AXTreeID GetAXTreeID() = 0;
// Returns the SiteInstance grouping all RenderFrameHosts that have script
// access to this RenderFrameHost, and must therefore live in the same
// process.
virtual SiteInstance* GetSiteInstance() = 0;
// Returns the interface for the Global Resource Coordinator
// for this frame.
virtual resource_coordinator::FrameResourceCoordinator*
GetFrameResourceCoordinator() = 0;
// Returns the process for this frame.
virtual RenderProcessHost* GetProcess() = 0;
// Returns the RenderWidgetHostView that can be used to control focus and
// visibility for this frame.
virtual RenderWidgetHostView* GetView() = 0;
// Returns the current RenderFrameHost of the parent frame, or nullptr if
// there is no parent. The result may be in a different process than the
// current RenderFrameHost.
virtual RenderFrameHost* GetParent() = 0;
// Returns whether or not this RenderFrameHost is a descendant of |ancestor|.
// This is equivalent to check that |ancestor| is reached by iterating on
// GetParent().
// This is a strict relationship, a RenderFrameHost is never an ancestor of
// itself.
virtual bool IsDescendantOf(RenderFrameHost* ancestor) = 0;
// Returns the FrameTreeNode ID for this frame. This ID is browser-global and
// uniquely identifies a frame that hosts content. The identifier is fixed at
// the creation of the frame and stays constant for the lifetime of the frame.
// When the frame is removed, the ID is not used again.
// A RenderFrameHost is tied to a process. Due to cross-process navigations,
// the RenderFrameHost may have a shorter lifetime than a frame. Consequently,
// the same FrameTreeNode ID may refer to a different RenderFrameHost after a
// navigation.
virtual int GetFrameTreeNodeId() = 0;
// Used for devtools instrumentation and trace-ability. The token is
// propagated to Blink's LocalFrame and both Blink and content/
// can tag calls and requests with this token in order to attribute them
// to the context frame. The token is only defined by the browser process and
// is never sent back from the renderer in the control calls. It should be
// never used to look up the FrameTreeNode instance.
virtual base::UnguessableToken GetDevToolsFrameToken() = 0;
// Returns the assigned name of the frame, the name of the iframe tag
// declaring it. For example, <iframe name="framename">[...]</iframe>. It is
// quite possible for a frame to have no name, in which case GetFrameName will
// return an empty string.
virtual const std::string& GetFrameName() = 0;
// Returns true if the frame is out of process.
virtual bool IsCrossProcessSubframe() = 0;
// Returns the last committed URL of the frame.
virtual const GURL& GetLastCommittedURL() = 0;
// Returns the last committed origin of the frame.
virtual const url::Origin& GetLastCommittedOrigin() = 0;
// Returns the associated widget's native view.
virtual gfx::NativeView GetNativeView() = 0;
// Adds |message| to the DevTools console.
virtual void AddMessageToConsole(ConsoleMessageLevel level,
const std::string& message) = 0;
// Runs some JavaScript in this frame's context. If a callback is provided, it
// will be used to return the result, when the result is available.
// This API can only be called on chrome:// or chrome-devtools:// URLs.
typedef base::Callback<void(const base::Value*)> JavaScriptResultCallback;
virtual void ExecuteJavaScript(const base::string16& javascript) = 0;
virtual void ExecuteJavaScript(const base::string16& javascript,
const JavaScriptResultCallback& callback) = 0;
// Runs some JavaScript in an isolated world of top of this frame's context.
virtual void ExecuteJavaScriptInIsolatedWorld(
const base::string16& javascript,
const JavaScriptResultCallback& callback,
int world_id) = 0;
// ONLY FOR TESTS: Same as above but without restrictions. Optionally, adds a
// fake UserGestureIndicator around execution. (
virtual void ExecuteJavaScriptForTests(const base::string16& javascript) = 0;
virtual void ExecuteJavaScriptForTests(
const base::string16& javascript,
const JavaScriptResultCallback& callback) = 0;
virtual void ExecuteJavaScriptWithUserGestureForTests(
const base::string16& javascript) = 0;
// Send a message to the RenderFrame to trigger an action on an
// accessibility object.
virtual void AccessibilityPerformAction(const ui::AXActionData& data) = 0;
// This is called when the user has committed to the given find in page
// request (e.g. by pressing enter or by clicking on the next / previous
// result buttons). It triggers sending a native accessibility event on
// the result object on the page, navigating assistive technology to that
// result.
virtual void ActivateFindInPageResultForAccessibility(int request_id) = 0;
// Roundtrips through the renderer and compositor pipeline to ensure that any
// changes to the contents resulting from operations executed prior to this
// call are visible on screen. The call completes asynchronously by running
// the supplied |callback| with a value of true upon successful completion and
// false otherwise (when the frame is destroyed, detached, etc..).
using VisualStateCallback = base::OnceCallback<void(bool)>;
virtual void InsertVisualStateCallback(VisualStateCallback callback) = 0;
// Copies the image at the location in viewport coordinates (not frame
// coordinates) to the clipboard. If there is no image at that location, does
// nothing.
virtual void CopyImageAt(int x, int y) = 0;
// Requests to save the image at the location in viewport coordinates (not
// frame coordinates). If there is an image at the location, the renderer
// will post back the appropriate download message to trigger the save UI.
// If there is no image at that location, does nothing.
virtual void SaveImageAt(int x, int y) = 0;
// RenderViewHost for this frame.
virtual RenderViewHost* GetRenderViewHost() = 0;
// Returns the InterfaceProvider that this process can use to bind
// interfaces exposed to it by the application running in this frame.
virtual service_manager::InterfaceProvider* GetRemoteInterfaces() = 0;
// Returns the AssociatedInterfaceProvider that this process can use to access
// remote frame-specific Channel-associated interfaces for this frame.
virtual blink::AssociatedInterfaceProvider*
GetRemoteAssociatedInterfaces() = 0;
// Returns the visibility state of the frame. The different visibility states
// of a frame are defined in Blink.
virtual PageVisibilityState GetVisibilityState() = 0;
// Returns whether the RenderFrame in the renderer process has been created
// and still has a connection. This is valid for all frames.
virtual bool IsRenderFrameLive() = 0;
// Returns true if this is the currently-visible RenderFrameHost for our frame
// tree node. During process transfer, a RenderFrameHost may be created that
// is not current. After process transfer, the old RenderFrameHost becomes
// non-current until it is deleted (which may not happen until its unload
// handler runs).
// Changes to the IsCurrent() state of a RenderFrameHost may be observed via
// WebContentsObserver::RenderFrameHostChanged().
virtual bool IsCurrent() = 0;
// Get the number of proxies to this frame, in all processes. Exposed for
// use by resource metrics.
virtual int GetProxyCount() = 0;
// Returns true if the frame has a selection.
virtual bool HasSelection() = 0;
// Text surrounding selection.
typedef base::Callback<
void(const base::string16& content, int start_offset, int end_offset)>
virtual void RequestTextSurroundingSelection(
const TextSurroundingSelectionCallback& callback,
int max_length) = 0;
// Tell the render frame to enable a set of javascript bindings. The argument
// should be a combination of values from BindingsPolicy.
virtual void AllowBindings(int binding_flags) = 0;
// Returns a bitwise OR of bindings types that have been enabled for this
// RenderFrame. See BindingsPolicy for details.
virtual int GetEnabledBindings() const = 0;
#if defined(OS_ANDROID)
// Returns an InterfaceProvider for Java-implemented interfaces that are
// scoped to this RenderFrameHost. This provides access to interfaces
// implemented in Java in the browser process to C++ code in the browser
// process.
virtual service_manager::InterfaceProvider* GetJavaInterfaces() = 0;
#endif // OS_ANDROID
// Stops and disables the hang monitor for beforeunload. This avoids flakiness
// in tests that need to observe beforeunload dialogs, which could fail if the
// timeout skips the dialog.
virtual void DisableBeforeUnloadHangMonitorForTesting() = 0;
virtual bool IsBeforeUnloadHangMonitorDisabledForTesting() = 0;
// Check whether the specific Blink feature is currently preventing fast
// shutdown of the frame.
virtual bool GetSuddenTerminationDisablerState(
blink::WebSuddenTerminationDisablerType disabler_type) = 0;
// Returns true if the given Feature Policy |feature| is enabled for this
// RenderFrameHost and is allowed to be used by it. Use this in the browser
// process to determine whether access to a feature is allowed.
virtual bool IsFeatureEnabled(blink::mojom::FeaturePolicyFeature feature) = 0;
// Opens view-source tab for the document last committed in this
// RenderFrameHost.
virtual void ViewSource() = 0;
// Starts pausing subresource loading on this frame and returns
// PauseSubresourceLoadingHandle that controls the pausing behavior. As long
// as this handle is live, pausing will continue until an internal
// navigation happens in the frame.
virtual blink::mojom::PauseSubresourceLoadingHandlePtr
PauseSubresourceLoading() = 0;
// Run the given action on the media player location at the given point.
virtual void ExecuteMediaPlayerActionAtLocation(
const gfx::Point& location,
const blink::WebMediaPlayerAction& action) = 0;
// Creates a Network Service-backed factory from appropriate |NetworkContext|.
// If this returns true, any redirect safety checks should be bypassed in
// downstream loaders.
virtual bool CreateNetworkServiceDefaultFactory(
network::mojom::URLLoaderFactoryRequest default_factory_request) = 0;
// Requests that future URLLoaderFactoryBundle(s) sent to the renderer should
// use a separate URLLoaderFactory for requests initiated by any of the
// origins listed in |request_initiators|. The URLLoaderFactory(s) for each
// origin will be created via
// ContentBrowserClient::CreateURLLoaderFactoryForNetworkRequests method.
virtual void MarkInitiatorsAsRequiringSeparateURLLoaderFactory(
base::flat_set<url::Origin> request_initiators,
bool push_to_renderer_now) = 0;
// Returns true if the given sandbox flag |flags| is in effect on this frame.
// The effective flags include those which have been set by a
// Content-Security-Policy header, in addition to those which are set by the
// embedding frame.
virtual bool IsSandboxed(blink::WebSandboxFlags flags) const = 0;
// Calls |FlushForTesting()| on Network Service and FrameNavigationControl
// related interfaces to make sure all in-flight mojo messages have been
// received by the other end. For test use only.
virtual void FlushNetworkAndNavigationInterfacesForTesting() = 0;
// Prepares this frame for attaching an inner WebContents to its own (outer)
// WebContents. This includes canceling all navigation requests as well as
// reseting the loading state. Returns false if attaching is not possible (
// if this is a main frame or a cross-process subframe), or true otherwise.
// Note: if this is called during an ongoing navigation it is not safe to
// attach WebContentses immediately after returning from this function (post
// task to ensure all observer calls related to the navigation complete).
virtual bool PrepareForInnerWebContentsAttach() = 0;
// This interface should only be implemented inside content.
friend class RenderFrameHostImpl;
RenderFrameHost() {}
} // namespace content