blob: 0a620c448b254ad8a9dfbf3f11b70b79a7c2ed31 [file] [log] [blame]
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_TEST_TEST_RENDER_FRAME_HOST_H_
#define CONTENT_TEST_TEST_RENDER_FRAME_HOST_H_
#include <stdint.h>
#include <map>
#include <optional>
#include <string>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "content/browser/renderer_host/render_frame_host_impl.h"
#include "content/common/navigation_client.mojom-forward.h"
#include "content/public/browser/web_contents_observer.h"
#include "content/public/test/mock_render_process_host.h"
#include "content/public/test/test_renderer_host.h"
#include "content/test/mock_agent_scheduling_group_host.h"
#include "content/test/test_page.h"
#include "content/test/test_render_view_host.h"
#include "content/test/test_render_widget_host.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "services/network/public/cpp/permissions_policy/permissions_policy_declaration.h"
#include "third_party/blink/public/common/tokens/tokens.h"
#include "third_party/blink/public/mojom/loader/transferrable_url_loader.mojom.h"
#include "third_party/blink/public/mojom/navigation/navigation_params.mojom-forward.h"
#include "third_party/blink/public/mojom/security_context/insecure_request_policy.mojom-forward.h"
#include "third_party/blink/public/mojom/usb/web_usb_service.mojom-forward.h"
#include "ui/base/page_transition_types.h"
#if !BUILDFLAG(IS_ANDROID)
#include "third_party/blink/public/mojom/hid/hid.mojom-forward.h"
#endif // !BUILDFLAG(IS_ANDROID)
namespace content {
class TestRenderFrameHostCreationObserver : public WebContentsObserver {
public:
explicit TestRenderFrameHostCreationObserver(WebContents* web_contents);
~TestRenderFrameHostCreationObserver() override;
// WebContentsObserver implementation.
void RenderFrameCreated(RenderFrameHost* render_frame_host) override;
void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
RenderFrameHost* last_created_frame() const { return last_created_frame_; }
private:
raw_ptr<RenderFrameHost> last_created_frame_ = nullptr;
};
class TestRenderFrameHost : public RenderFrameHostImpl,
public RenderFrameHostTester {
public:
TestRenderFrameHost(
SiteInstance* site_instance,
scoped_refptr<RenderViewHostImpl> render_view_host,
RenderFrameHostDelegate* delegate,
FrameTree* frame_tree,
FrameTreeNode* frame_tree_node,
int32_t routing_id,
mojo::PendingAssociatedRemote<mojom::Frame> frame_remote,
const blink::LocalFrameToken& frame_token,
const blink::DocumentToken& document_token,
base::UnguessableToken devtools_frame_token,
LifecycleStateImpl lifecycle_state,
scoped_refptr<BrowsingContextState> browsing_context_state);
TestRenderFrameHost(const TestRenderFrameHost&) = delete;
TestRenderFrameHost& operator=(const TestRenderFrameHost&) = delete;
~TestRenderFrameHost() override;
// Flushes mojo messages on `local_frame_`.
void FlushLocalFrameMessages();
// RenderFrameHostImpl overrides (same values, but in Test*/Mock* types)
TestRenderViewHost* GetRenderViewHost() const override;
TestPage& GetPage() override;
MockRenderProcessHost* GetProcess() const override;
MockAgentSchedulingGroupHost& GetAgentSchedulingGroup() override;
TestRenderWidgetHost* GetRenderWidgetHost() override;
void AddMessageToConsole(blink::mojom::ConsoleMessageLevel level,
const std::string& message) override;
void ReportInspectorIssue(blink::mojom::InspectorIssueInfoPtr issue) override;
bool IsTestRenderFrameHost() const override;
// Public overrides to expose RenderFrameHostImpl's mojo methods to tests.
void DidFailLoadWithError(const GURL& url, int error_code) override;
// RenderFrameHostTester implementation.
void InitializeRenderFrameIfNeeded() override;
TestRenderFrameHost* AppendChild(const std::string& frame_name) override;
TestRenderFrameHost* AppendChildWithPolicy(
const std::string& frame_name,
const network::ParsedPermissionsPolicy& allow) override;
TestRenderFrameHost* AppendCredentiallessChild(
const std::string& frame_name) override;
void Detach() override;
void SendNavigateWithTransition(int nav_entry_id,
bool did_create_new_entry,
const GURL& url,
ui::PageTransition transition);
void SimulateBeforeUnloadCompleted(bool proceed) override;
void SimulateUnloadACK() override;
void SimulateUserActivation() override;
const std::vector<std::string>& GetConsoleMessages() override;
void ClearConsoleMessages() override;
int GetHeavyAdIssueCount(HeavyAdIssueType type) override;
void SimulateManifestURLUpdate(const GURL& manifest_url) override;
TestRenderFrameHost* AppendFencedFrame() override;
void CreateWebUsbServiceForTesting(
mojo::PendingReceiver<blink::mojom::WebUsbService> receiver) override;
void ResetLocalFrame() override;
#if !BUILDFLAG(IS_ANDROID)
void CreateHidServiceForTesting(
mojo::PendingReceiver<blink::mojom::HidService> receiver) override;
#endif // !BUILDFLAG(IS_ANDROID)
void SendNavigate(int nav_entry_id,
bool did_create_new_entry,
const GURL& url);
void SendNavigateWithParams(mojom::DidCommitProvisionalLoadParamsPtr params,
bool was_within_same_document);
void SendNavigateWithParamsAndInterfaceParams(
mojom::DidCommitProvisionalLoadParamsPtr params,
mojom::DidCommitProvisionalLoadInterfaceParamsPtr interface_params,
bool was_within_same_document);
void SendDidCommitSameDocumentNavigation(
mojom::DidCommitProvisionalLoadParamsPtr params,
blink::mojom::SameDocumentNavigationType same_document_navigation_type,
bool should_replace_current_entry);
void SendStartLoadingForAsyncNavigationApiCommit();
// With the current navigation logic this method is a no-op.
// Simulates a renderer-initiated navigation to |url| starting in the
// RenderFrameHost.
// DEPRECATED: use NavigationSimulator instead.
void SimulateNavigationStart(const GURL& url);
// Simulates a redirect to |new_url| for the navigation in the
// RenderFrameHost.
// DEPRECATED: use NavigationSimulator instead.
void SimulateRedirect(const GURL& new_url);
// This method simulates receiving a BeginNavigation IPC.
// DEPRECATED: use NavigationSimulator instead.
void SendRendererInitiatedNavigationRequest(const GURL& url,
bool has_user_gesture);
void SimulateDidChangeOpener(
const std::optional<blink::LocalFrameToken>& opener_frame_token);
void DidEnforceInsecureRequestPolicy(
blink::mojom::InsecureRequestPolicy policy);
// Returns the number of FedCM issues of FederatedAuthRequestResult type
// `status_type` sent to DevTools. If `status_type` is std::nullopt, returns
// the total number of FedCM issues of any type sent to DevTools.
int GetFederatedAuthRequestIssueCount(
std::optional<blink::mojom::FederatedAuthRequestResult> status_type);
// Returns the number of FedCM issues of FederatedAuthUserInfoRequestResult
// type `status_type` sent to DevTools. If `status_type` is std::nullopt,
// returns the total number of FedCM issues of any type sent to DevTools.
int GetFederatedAuthUserInfoRequestIssueCount(
std::optional<blink::mojom::FederatedAuthUserInfoRequestResult>
status_type);
// If set, navigations will appear to have cleared the history list in the
// RenderFrame (DidCommitProvisionalLoadParams::history_list_was_cleared).
// False by default.
void set_simulate_history_list_was_cleared(bool cleared) {
simulate_history_list_was_cleared_ = cleared;
}
// Advances the RenderFrameHost (and through it the RenderFrameHostManager) to
// a state where a new navigation can be committed by a renderer. This
// simulates a BeforeUnload completion callback from the renderer, and the
// interaction with the IO thread up until the response is ready to commit.
void PrepareForCommit();
// Like PrepareForCommit, but with the socket address when needed.
// TODO(clamy): Have NavigationSimulator make the relevant calls directly and
// remove this function.
void PrepareForCommitDeprecatedForNavigationSimulator(
network::mojom::URLResponseHeadPtr response,
mojo::ScopedDataPipeConsumerHandle response_body);
// Used to simulate the commit of a navigation having been processed in the
// renderer. If parameters required to commit are not provided, they will be
// set to default null values.
void SimulateCommitProcessed(
NavigationRequest* navigation_request,
mojom::DidCommitProvisionalLoadParamsPtr params,
mojo::PendingReceiver<blink::mojom::BrowserInterfaceBroker>
browser_interface_broker_receiver,
bool same_document);
// Returns a pending Frame remote that represents a connection to a non-
// existent renderer, where all messages will go into the void.
static mojo::PendingAssociatedRemote<mojom::Frame> CreateStubFrameRemote();
// Returns a PendingReceiver<BrowserInterfaceBroker> that is safe to bind to
// an implementation, but will never receive any interface requests.
static mojo::PendingReceiver<blink::mojom::BrowserInterfaceBroker>
CreateStubBrowserInterfaceBrokerReceiver();
// Returns an `AssociatedInterfaceProvider` that will never receive any
// interface requests.
static mojo::PendingAssociatedReceiver<
blink::mojom::AssociatedInterfaceProvider>
CreateStubAssociatedInterfaceProviderReceiver();
// Returns a blink::mojom::PolicyContainerBindParams containing a
// PendingAssociatedReceiver<PolicyContainerHost> and a
// PendingReceiver<PolicyContainerHostKeepAliveHandle> that are safe to bind
// to an implementation, but will never receive any interface requests. To be
// passed to RenderFrameHostImpl::CreateChildFrame.
static blink::mojom::PolicyContainerBindParamsPtr
CreateStubPolicyContainerBindParams();
// This simulates aborting a cross document navigation.
// Will abort the navigation with the given |navigation_id|.
void AbortCommit(NavigationRequest* navigation_request);
// Returns the navigations that are trying to commit.
const std::map<NavigationRequest*, std::unique_ptr<NavigationRequest>>&
navigation_requests() {
return navigation_requests_;
}
enum class LoadingScenario {
NewDocumentNavigation,
kSameDocumentNavigation,
// TODO(altimin): Improve handling for the scenarios where navigation or
// page load have failed.
kOther
};
// Simulates RenderFrameHost finishing loading and dispatching all relevant
// callbacks.
void SimulateLoadingCompleted(LoadingScenario loading_scenario);
void set_on_sendbeforeunload_begin(
base::OnceClosure on_sendbeforeunload_begin) {
on_sendbeforeunload_begin_ = std::move(on_sendbeforeunload_begin);
}
void set_on_sendbeforeunload_end(base::OnceClosure on_sendbeforeunload_end) {
on_sendbeforeunload_end_ = std::move(on_sendbeforeunload_end);
}
// Expose this for testing.
using RenderFrameHostImpl::SetPolicyContainerHost;
protected:
void SendCommitNavigation(
mojom::NavigationClient* navigation_client,
NavigationRequest* navigation_request,
blink::mojom::CommonNavigationParamsPtr common_params,
blink::mojom::CommitNavigationParamsPtr commit_params,
network::mojom::URLResponseHeadPtr response_head,
mojo::ScopedDataPipeConsumerHandle response_body,
network::mojom::URLLoaderClientEndpointsPtr url_loader_client_endpoints,
std::unique_ptr<blink::PendingURLLoaderFactoryBundle>
subresource_loader_factories,
std::optional<std::vector<blink::mojom::TransferrableURLLoaderPtr>>
subresource_overrides,
blink::mojom::ControllerServiceWorkerInfoPtr
controller_service_worker_info,
blink::mojom::ServiceWorkerContainerInfoForClientPtr container_info,
mojo::PendingRemote<network::mojom::URLLoaderFactory>
subresource_proxying_loader_factory,
mojo::PendingRemote<network::mojom::URLLoaderFactory>
keep_alive_loader_factory,
mojo::PendingAssociatedRemote<blink::mojom::FetchLaterLoaderFactory>
fetch_later_loader_factory,
const std::optional<network::ParsedPermissionsPolicy>& permissions_policy,
blink::mojom::PolicyContainerPtr policy_container,
const blink::DocumentToken& document_token,
const base::UnguessableToken& devtools_navigation_token) override;
void SendCommitFailedNavigation(
mojom::NavigationClient* navigation_client,
NavigationRequest* navigation_request,
blink::mojom::CommonNavigationParamsPtr common_params,
blink::mojom::CommitNavigationParamsPtr commit_params,
bool has_stale_copy_in_cache,
int32_t error_code,
int32_t extended_error_code,
const std::optional<std::string>& error_page_content,
std::unique_ptr<blink::PendingURLLoaderFactoryBundle>
subresource_loader_factories,
const blink::DocumentToken& document_token,
const base::UnguessableToken& devtools_navigation_token,
blink::mojom::PolicyContainerPtr policy_container) override;
void SendBeforeUnload(bool is_reload,
base::WeakPtr<RenderFrameHostImpl> impl,
bool for_legacy,
const bool is_renderer_initiated_navigation) override;
private:
void SendNavigateWithParameters(int nav_entry_id,
bool did_create_new_entry,
const GURL& url,
ui::PageTransition transition,
int response_code);
void PrepareForCommitInternal(
network::mojom::URLResponseHeadPtr response,
mojo::ScopedDataPipeConsumerHandle response_body);
// Computes the page ID for a pending navigation in this RenderFrameHost;
int32_t ComputeNextPageID();
mojom::DidCommitProvisionalLoadParamsPtr BuildDidCommitParams(
bool did_create_new_entry,
const GURL& url,
ui::PageTransition transition,
int response_code,
bool is_same_document);
mojom::DidCommitProvisionalLoadInterfaceParamsPtr
BuildDidCommitInterfaceParams(bool is_same_document);
// Keeps a running vector of messages sent to AddMessageToConsole.
std::vector<std::string> console_messages_;
// Keep a count of the heavy ad issues sent to ReportInspectorIssue.
int heavy_ad_issue_network_count_ = 0;
int heavy_ad_issue_cpu_total_count_ = 0;
int heavy_ad_issue_cpu_peak_count_ = 0;
// Keeps a count of federated authentication request issues sent to
// ReportInspectorIssue.
std::unordered_map<blink::mojom::FederatedAuthRequestResult, int>
federated_auth_counts_;
// Keeps a count of getUserInfo() issues sent to ReportInspectorIssue.
std::unordered_map<blink::mojom::FederatedAuthUserInfoRequestResult, int>
federated_auth_user_info_counts_;
TestRenderFrameHostCreationObserver child_creation_observer_;
// See set_simulate_history_list_was_cleared() above.
bool simulate_history_list_was_cleared_;
// The last commit was for an error page.
bool last_commit_was_error_page_;
// The closure that runs when SendBeforeUnload is called.
base::OnceClosure on_sendbeforeunload_begin_;
base::OnceClosure on_sendbeforeunload_end_;
std::map<NavigationRequest*,
mojom::NavigationClient::CommitNavigationCallback>
commit_callback_;
std::map<NavigationRequest*,
mojom::NavigationClient::CommitFailedNavigationCallback>
commit_failed_callback_;
};
} // namespace content
#endif // CONTENT_TEST_TEST_RENDER_FRAME_HOST_H_