// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromecast/browser/cast_web_contents_impl.h"
#include <optional>
#include <string_view>
#include <utility>
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/no_destructor.h"
#include "base/ranges/algorithm.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/sequenced_task_runner.h"
#include "base/trace_event/trace_event.h"
#include "base/values.h"
#include "chromecast/base/cast_features.h"
#include "chromecast/base/chromecast_switches.h"
#include "chromecast/base/metrics/cast_metrics_helper.h"
#include "chromecast/browser/cast_browser_process.h"
#include "chromecast/browser/cast_navigation_ui_data.h"
#include "chromecast/browser/cast_permission_user_data.h"
#include "chromecast/browser/cast_session_id_map.h"
#include "chromecast/browser/devtools/remote_debugging_server.h"
#include "chromecast/common/mojom/activity_url_filter.mojom.h"
#include "chromecast/common/mojom/queryable_data_store.mojom.h"
#include "chromecast/common/queryable_data.h"
#include "chromecast/net/connectivity_checker.h"
#include "components/cast/message_port/blink_message_port_adapter.h"
#include "components/cast/message_port/cast/message_port_cast.h"
#include "components/media_control/browser/media_blocker.h"
#include "components/media_control/mojom/media_playback_options.mojom.h"
#include "content/public/browser/message_port_provider.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/navigation_handle.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/common/bindings_policy.h"
#include "media/mojo/buildflags.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "net/base/net_errors.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
#include "third_party/blink/public/common/navigation/navigation_params.h"
#include "third_party/blink/public/common/renderer_preferences/renderer_preferences.h"
#include "third_party/blink/public/mojom/autoplay/autoplay.mojom.h"
#include "third_party/blink/public/mojom/favicon/favicon_url.mojom.h"
#include "third_party/blink/public/mojom/loader/resource_load_info.mojom.h"
#include "third_party/skia/include/core/SkColor.h"
#include "url/gurl.h"
namespace chromecast {
namespace {
// IDs start at 1, since 0 is reserved for the root content window.
size_t next_tab_id = 1;
// Next id for id()
size_t next_id = 0;
// Remove the given CastWebContents pointer from the global instance vector.
void RemoveCastWebContents(CastWebContents* instance) {
auto& all_cast_web_contents = CastWebContents::GetAll();
auto it = base::ranges::find(all_cast_web_contents, instance);
if (it != all_cast_web_contents.end()) {
all_cast_web_contents.erase(it);
}
}
content::mojom::RendererType ToContentRendererType(mojom::RendererType type) {
switch (type) {
case mojom::RendererType::DEFAULT_RENDERER:
return content::mojom::RendererType::DEFAULT_RENDERER;
case mojom::RendererType::MOJO_RENDERER:
return content::mojom::RendererType::MOJO_RENDERER;
case mojom::RendererType::REMOTING_RENDERER:
return content::mojom::RendererType::REMOTING_RENDERER;
}
}
} // namespace
// static
std::vector<CastWebContents*>& CastWebContents::GetAll() {
static base::NoDestructor<std::vector<CastWebContents*>> instance;
return *instance;
}
// static
CastWebContents* CastWebContents::FromWebContents(
content::WebContents* web_contents) {
auto& all_cast_web_contents = CastWebContents::GetAll();
auto it = base::ranges::find(all_cast_web_contents, web_contents,
&CastWebContents::web_contents);
if (it == all_cast_web_contents.end()) {
return nullptr;
}
return *it;
}
void CastWebContentsImpl::RenderProcessReady(content::RenderProcessHost* host) {
DCHECK(host->IsReady());
const base::Process& process = host->GetProcess();
for (auto& observer : observers_) {
observer->OnRenderProcessReady(process.Pid());
}
}
void CastWebContentsImpl::RenderProcessExited(
content::RenderProcessHost* host,
const content::ChildProcessTerminationInfo& info) {
RemoveRenderProcessHostObserver();
}
void CastWebContentsImpl::RenderProcessHostDestroyed(
content::RenderProcessHost* host) {
RemoveRenderProcessHostObserver();
}
void CastWebContentsImpl::RemoveRenderProcessHostObserver() {
if (main_process_host_) {
main_process_host_->RemoveObserver(this);
}
main_process_host_ = nullptr;
}
CastWebContentsImpl::CastWebContentsImpl(content::WebContents* web_contents,
mojom::CastWebViewParamsPtr params)
: CastWebContentsImpl(web_contents,
std::move(params),
nullptr /* parent */) {}
CastWebContentsImpl::CastWebContentsImpl(content::WebContents* web_contents,
mojom::CastWebViewParamsPtr params,
CastWebContents* parent)
: web_contents_(web_contents),
params_(std::move(params)),
page_state_(PageState::IDLE),
last_state_(PageState::IDLE),
remote_debugging_server_(
shell::CastBrowserProcess::GetInstance()->remote_debugging_server()),
media_blocker_(params_->use_media_blocker
? std::make_unique<CastMediaBlocker>(web_contents_)
: nullptr),
main_process_host_(nullptr),
parent_cast_web_contents_(parent),
tab_id_(params_->is_root_window ? 0 : next_tab_id++),
id_(next_id++),
main_frame_loaded_(false),
closing_(false),
stopped_(false),
stop_notified_(false),
notifying_(false),
last_error_(net::OK),
task_runner_(base::SequencedTaskRunner::GetCurrentDefault()),
weak_factory_(this) {
DCHECK(web_contents_);
DCHECK(web_contents_->GetController().IsInitialNavigation());
DCHECK(!web_contents_->IsLoading());
DCHECK(web_contents_->GetPrimaryMainFrame());
main_process_host_ = web_contents_->GetPrimaryMainFrame()->GetProcess();
DCHECK(main_process_host_);
main_process_host_->AddObserver(this);
CastWebContents::GetAll().push_back(this);
content::WebContentsObserver::Observe(web_contents_);
// The URL rewrite rules manager must be initialized only for the root
// CastWebContents that is created with this public ctor. All the inner
// CastWebContents created in |InnerWebContentsCreated()| callback will use
// the private ctor with |parent| specified which allows sharing the same
// manager, so that the whole Cast session applies the same rules.
if (params_->enable_url_rewrite_rules) {
if (!parent_cast_web_contents_) {
url_rewrite_rules_manager_.emplace();
}
url_rewrite_rules_manager()->AddWebContents(web_contents_);
}
if (params_->enabled_for_dev) {
LOG(INFO) << "Enabling dev console for CastWebContentsImpl";
remote_debugging_server_->EnableWebContentsForDebugging(web_contents_);
}
// TODO(yucliu): Change the flag name to kDisableCmaRenderer in a latter diff.
if (GetSwitchValueBoolean(switches::kDisableMojoRenderer, false) &&
params_->renderer_type == mojom::RendererType::MOJO_RENDERER) {
params_->renderer_type = mojom::RendererType::DEFAULT_RENDERER;
} else if (GetSwitchValueBoolean(switches::kForceMojoRenderer, false)) {
#if BUILDFLAG(ENABLE_MOJO_RENDERER) && BUILDFLAG(ENABLE_CAST_RENDERER)
LOG(INFO) << "Enabling mojo renderer";
#else
LOG(ERROR)
<< "The switch " << switches::kForceMojoRenderer
<< " was used, but either the mojo renderer or cast renderer is "
"disabled via GN args. Check the values of enable_cast_renderer and "
"mojo_media_services in your GN args";
#endif // BUILDFLAG(ENABLE_MOJO_RENDERER) && BUILDFLAG(ENABLE_CAST_RENDERER)
params_->renderer_type = mojom::RendererType::MOJO_RENDERER;
}
web_contents_->SetPageBaseBackgroundColor(chromecast::GetSwitchValueColor(
switches::kCastAppBackgroundColor, SK_ColorBLACK));
if (params_->enable_webui_bindings_permission) {
web_contents_->GetPrimaryMainFrame()->AllowBindings(
content::kWebUIBindingsPolicySet);
}
}
CastWebContentsImpl::~CastWebContentsImpl() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(!notifying_) << "Do not destroy CastWebContents during observer "
"notification!";
RemoveRenderProcessHostObserver();
DisableDebugging();
observers_.Clear();
for (auto& observer : sync_observers_) {
observer.ResetCastWebContents();
}
RemoveCastWebContents(this);
}
int CastWebContentsImpl::tab_id() const {
return tab_id_;
}
int CastWebContentsImpl::id() const {
return id_;
}
content::WebContents* CastWebContentsImpl::web_contents() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return web_contents_;
}
PageState CastWebContentsImpl::page_state() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return page_state_;
}
url_rewrite::UrlRequestRewriteRulesManager*
CastWebContentsImpl::url_rewrite_rules_manager() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (parent_cast_web_contents_) {
return parent_cast_web_contents_->url_rewrite_rules_manager();
}
return &*url_rewrite_rules_manager_;
}
const media_control::MediaBlocker* CastWebContentsImpl::media_blocker() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return media_blocker_.get();
}
void CastWebContentsImpl::AddRendererFeatures(base::Value::Dict features) {
renderer_features_ = std::move(features);
}
void CastWebContentsImpl::SetInterfacesForRenderer(
mojo::PendingRemote<mojom::RemoteInterfaces> remote_interfaces) {
remote_interfaces_.SetProvider(std::move(remote_interfaces));
}
void CastWebContentsImpl::SetUrlRewriteRules(
url_rewrite::mojom::UrlRequestRewriteRulesPtr rules) {
DCHECK(params_->enable_url_rewrite_rules);
if (!url_rewrite_rules_manager()->OnRulesUpdated(std::move(rules))) {
LOG(ERROR) << "URL rewrite rules update failed.";
}
}
void CastWebContentsImpl::LoadUrl(const GURL& url) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (api_bindings_ && !bindings_received_) {
LOG(INFO) << "Will load URL: " << url.possibly_invalid_spec()
<< " once bindings has been received.";
pending_load_url_ = url;
return;
}
if (!web_contents_) {
LOG(ERROR) << "Cannot load URL for deleted WebContents";
return;
}
if (closing_) {
LOG(ERROR) << "Cannot load URL for WebContents while closing";
return;
}
OnPageLoading();
LOG(INFO) << "Load url: " << url.possibly_invalid_spec();
web_contents_->GetController().LoadURL(url, content::Referrer(),
ui::PAGE_TRANSITION_TYPED, "");
UpdatePageState();
DCHECK_EQ(PageState::LOADING, page_state_);
NotifyPageState();
}
void CastWebContentsImpl::ClosePage() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!web_contents_ || closing_) {
return;
}
closing_ = true;
web_contents_->DispatchBeforeUnload(false /* auto_cancel */);
web_contents_->ClosePage();
// If the WebContents doesn't close within the specified timeout, then signal
// the page closure anyway so that the Delegate can delete the WebContents and
// stop the page itself.
task_runner_->PostDelayedTask(
FROM_HERE,
base::BindOnce(&CastWebContentsImpl::OnClosePageTimeout,
weak_factory_.GetWeakPtr()),
base::Milliseconds(1000));
}
void CastWebContentsImpl::Stop(int error_code) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (stopped_) {
UpdatePageState();
NotifyPageState();
return;
}
last_error_ = error_code;
closing_ = false;
stopped_ = true;
UpdatePageState();
DCHECK_NE(PageState::IDLE, page_state_);
DCHECK_NE(PageState::LOADING, page_state_);
DCHECK_NE(PageState::LOADED, page_state_);
NotifyPageState();
}
void CastWebContentsImpl::SetWebVisibilityAndPaint(bool visible) {
if (!web_contents_) {
return;
}
if (visible) {
web_contents_->WasShown();
} else {
web_contents_->WasHidden();
}
if (web_contents_->GetVisibility() != content::Visibility::VISIBLE) {
// Since we are managing the visibility, we need to ensure pages are
// unfrozen in the event this occurred while in the background.
web_contents_->SetPageFrozen(false);
}
}
void CastWebContentsImpl::BlockMediaLoading(bool blocked) {
if (media_blocker_) {
media_blocker_->BlockMediaLoading(blocked);
}
}
void CastWebContentsImpl::BlockMediaStarting(bool blocked) {
if (media_blocker_) {
media_blocker_->BlockMediaStarting(blocked);
}
}
void CastWebContentsImpl::EnableBackgroundVideoPlayback(bool enabled) {
if (media_blocker_) {
media_blocker_->EnableBackgroundVideoPlayback(enabled);
}
}
void CastWebContentsImpl::SetAppProperties(
const std::string& app_id,
const std::string& session_id,
bool is_audio_app,
const GURL& app_web_url,
bool enforce_feature_permissions,
const std::vector<int32_t>& feature_permissions,
const std::vector<std::string>& additional_feature_permission_origins) {
if (!web_contents_) {
return;
}
shell::CastNavigationUIData::SetAppPropertiesForWebContents(
web_contents_, session_id, is_audio_app);
new shell::CastPermissionUserData(
web_contents_, app_id, app_web_url, enforce_feature_permissions,
feature_permissions, additional_feature_permission_origins);
}
void CastWebContentsImpl::SetGroupInfo(const std::string& session_id,
bool is_multizone_launch) {
shell::CastSessionIdMap::GetInstance()->SetGroupInfo(session_id,
is_multizone_launch);
}
void CastWebContentsImpl::AddBeforeLoadJavaScript(uint64_t id,
std::string_view script) {
script_injector_.AddScriptForAllOrigins(id, std::string(script));
}
void CastWebContentsImpl::PostMessageToMainFrame(
const std::string& target_origin,
const std::string& data,
std::vector<blink::WebMessagePort> ports) {
DCHECK(!data.empty());
std::u16string data_utf16;
data_utf16 = base::UTF8ToUTF16(data);
// If origin is set as wildcard, no origin scoping would be applied.
std::optional<std::u16string> target_origin_utf16;
constexpr char kWildcardOrigin[] = "*";
if (target_origin != kWildcardOrigin) {
target_origin_utf16 = base::UTF8ToUTF16(target_origin);
}
content::MessagePortProvider::PostMessageToFrame(
web_contents()->GetPrimaryPage(), std::u16string(), target_origin_utf16,
data_utf16, std::move(ports));
}
void CastWebContentsImpl::ExecuteJavaScript(
const std::u16string& javascript,
base::OnceCallback<void(base::Value)> callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!web_contents_ || closing_ || !main_frame_loaded_ ||
!web_contents_->GetPrimaryMainFrame()) {
return;
}
web_contents_->GetPrimaryMainFrame()->ExecuteJavaScript(javascript,
std::move(callback));
}
void CastWebContentsImpl::ConnectToBindingsService(
mojo::PendingRemote<mojom::ApiBindings> api_bindings_remote) {
DCHECK(api_bindings_remote);
bindings_received_ = false;
named_message_port_connector_ =
std::make_unique<NamedMessagePortConnectorCast>(this);
named_message_port_connector_->RegisterPortHandler(base::BindRepeating(
&CastWebContentsImpl::OnPortConnected, base::Unretained(this)));
api_bindings_.Bind(std::move(api_bindings_remote));
// Fetch bindings and inject scripts into |script_injector_|.
api_bindings_->GetAll(base::BindOnce(&CastWebContentsImpl::OnBindingsReceived,
base::Unretained(this)));
}
void CastWebContentsImpl::SetEnabledForRemoteDebugging(bool enabled) {
DCHECK(remote_debugging_server_);
if (enabled && !params_->enabled_for_dev) {
LOG(INFO) << "Enabling dev console for CastWebContentsImpl";
remote_debugging_server_->EnableWebContentsForDebugging(web_contents_);
} else if (!enabled && params_->enabled_for_dev) {
LOG(INFO) << "Disabling dev console for CastWebContentsImpl";
remote_debugging_server_->DisableWebContentsForDebugging(web_contents_);
}
params_->enabled_for_dev = enabled;
// Propagate setting change to inner contents.
for (auto& inner : inner_contents_) {
inner->SetEnabledForRemoteDebugging(enabled);
}
}
void CastWebContentsImpl::GetMainFramePid(GetMainFramePidCallback cb) {
if (!web_contents_ || !web_contents_->GetPrimaryMainFrame()) {
std::move(cb).Run(base::kNullProcessHandle);
return;
}
auto* rph = web_contents_->GetPrimaryMainFrame()->GetProcess();
if (!rph || rph->GetProcess().Handle() == base::kNullProcessHandle) {
std::move(cb).Run(base::kNullProcessHandle);
return;
}
std::move(cb).Run(rph->GetProcess().Handle());
}
bool CastWebContentsImpl::TryBindReceiver(
mojo::GenericPendingReceiver& receiver) {
// First try binding local interfaces.
if (local_interfaces_.TryBindReceiver(receiver)) {
return true;
}
const std::string interface_name = *receiver.interface_name();
mojo::ScopedMessagePipeHandle interface_pipe = receiver.PassPipe();
receiver =
mojo::GenericPendingReceiver(interface_name, std::move(interface_pipe));
remote_interfaces_.Bind(std::move(receiver));
// The PendingReceiver has been passed along at this point, so return true.
// Note that this doesn't guarantee that the interface will eventually be
// connected.
return true;
}
InterfaceBundle* CastWebContentsImpl::local_interfaces() {
return &local_interfaces_;
}
bool CastWebContentsImpl::is_websql_enabled() {
return params_->enable_websql;
}
bool CastWebContentsImpl::is_mixer_audio_enabled() {
return params_->enable_mixer_audio;
}
void CastWebContentsImpl::OnClosePageTimeout() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!closing_ || stopped_) {
return;
}
closing_ = false;
Stop(net::OK);
}
void CastWebContentsImpl::RenderFrameCreated(
content::RenderFrameHost* frame_host) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(frame_host);
// TODO(b/187758538): Merge the two ConfigureFeatures() calls.
mojo::Remote<chromecast::shell::mojom::FeatureManager> feature_manager_remote;
frame_host->GetRemoteInterfaces()->GetInterface(
feature_manager_remote.BindNewPipeAndPassReceiver());
feature_manager_remote->ConfigureFeatures(GetRendererFeatures());
mojo::AssociatedRemote<chromecast::shell::mojom::FeatureManager>
feature_manager_associated_remote;
frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
&feature_manager_associated_remote);
feature_manager_associated_remote->ConfigureFeatures(GetRendererFeatures());
mojo::AssociatedRemote<components::media_control::mojom::MediaPlaybackOptions>
media_playback_options;
frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
&media_playback_options);
media_playback_options->SetRendererType(
ToContentRendererType(params_->renderer_type));
// Send queryable values
mojo::Remote<chromecast::shell::mojom::QueryableDataStore>
queryable_data_store_remote;
frame_host->GetRemoteInterfaces()->GetInterface(
queryable_data_store_remote.BindNewPipeAndPassReceiver());
for (const auto& value : QueryableData::GetValues()) {
// base::Value is not copyable.
queryable_data_store_remote->Set(value.first, value.second.Clone());
}
// Set up URL filter
if (params_->url_filters) {
mojo::AssociatedRemote<chromecast::mojom::ActivityUrlFilterConfiguration>
activity_filter_setter;
frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
&activity_filter_setter);
activity_filter_setter->SetFilter(
chromecast::mojom::ActivityUrlFilterCriteria::New(
params_->url_filters.value()));
}
// Set the background color for main frames.
if (!frame_host->GetParent()) {
if (params_->background_color == mojom::BackgroundColor::WHITE) {
frame_host->GetView()->SetBackgroundColor(SK_ColorWHITE);
} else if (params_->background_color == mojom::BackgroundColor::BLACK) {
frame_host->GetView()->SetBackgroundColor(SK_ColorBLACK);
} else if (params_->background_color ==
mojom::BackgroundColor::TRANSPARENT) {
frame_host->GetView()->SetBackgroundColor(SK_ColorTRANSPARENT);
} else {
frame_host->GetView()->SetBackgroundColor(chromecast::GetSwitchValueColor(
switches::kCastAppBackgroundColor, SK_ColorBLACK));
}
}
}
std::vector<chromecast::shell::mojom::FeaturePtr>
CastWebContentsImpl::GetRendererFeatures() {
std::vector<chromecast::shell::mojom::FeaturePtr> features;
for (const auto pair : renderer_features_) {
const std::string& name = pair.first;
const base::Value& config_value = pair.second;
const base::Value::Dict* maybe_config_dict = config_value.GetIfDict();
// There are only 2 callers of `AddRendererFeatures` (both in
// `runtime_application_service_impl.cc`) and they always provide
// well-formed dictionaries as values.
DCHECK(maybe_config_dict);
base::Value::Dict config_dict = maybe_config_dict->Clone();
features.push_back(
chromecast::shell::mojom::Feature::New(name, std::move(config_dict)));
}
return features;
}
void CastWebContentsImpl::OnBindingsReceived(
std::vector<chromecast::mojom::ApiBindingPtr> bindings) {
bindings_received_ = true;
if (bindings.empty()) {
LOG(ERROR) << "ApiBindings remote sent empty bindings. Stopping the page.";
Stop(net::ERR_UNEXPECTED);
} else {
constexpr uint64_t kBindingsIdStart = 0xFF0000;
// Enumerate and inject all scripts in |bindings|.
uint64_t bindings_id = kBindingsIdStart;
for (auto& entry : bindings) {
AddBeforeLoadJavaScript(bindings_id++, entry->script);
}
}
DVLOG(1) << "Bindings has been received. Start loading URL if requested.";
if (!pending_load_url_.is_empty()) {
auto gurl = std::move(pending_load_url_);
pending_load_url_ = GURL();
LoadUrl(gurl);
}
}
bool CastWebContentsImpl::OnPortConnected(
std::string_view port_name,
std::unique_ptr<cast_api_bindings::MessagePort> port) {
DCHECK(api_bindings_);
api_bindings_->Connect(
std::string(port_name),
cast_api_bindings::BlinkMessagePortAdapter::FromServerPlatformMessagePort(
std::move(port))
.PassPort());
return true;
}
void CastWebContentsImpl::PrimaryMainFrameRenderProcessGone(
base::TerminationStatus status) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
LOG(INFO) << "Render process for main frame exited unexpectedly.";
Stop(net::ERR_UNEXPECTED);
}
void CastWebContentsImpl::DidStartNavigation(
content::NavigationHandle* navigation_handle) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(navigation_handle);
if (!web_contents_ || closing_ || stopped_) {
return;
}
if (!navigation_handle->IsInMainFrame() ||
navigation_handle->IsSameDocument()) {
return;
}
// Main frame has an ongoing navigation. This might overwrite a
// previously active navigation. We only care about tracking
// the most recent main frame navigation.
active_navigation_ = navigation_handle;
// Main frame has begun navigating/loading.
LOG(INFO) << "Navigation started: " << navigation_handle->GetURL();
OnPageLoading();
start_loading_ticks_ = base::TimeTicks::Now();
GURL loading_url;
content::NavigationEntry* nav_entry =
web_contents()->GetController().GetVisibleEntry();
if (nav_entry) {
loading_url = nav_entry->GetVirtualURL();
}
TracePageLoadBegin(loading_url);
UpdatePageState();
DCHECK_EQ(page_state_, PageState::LOADING);
NotifyPageState();
}
void CastWebContentsImpl::DidRedirectNavigation(
content::NavigationHandle* navigation_handle) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(navigation_handle);
if (!web_contents_ || closing_ || stopped_) {
return;
}
if (!navigation_handle->IsInMainFrame()) {
return;
}
// Main frame navigation was redirected by the server.
LOG(INFO) << "Navigation was redirected by server: "
<< navigation_handle->GetURL();
}
void CastWebContentsImpl::ReadyToCommitNavigation(
content::NavigationHandle* navigation_handle) {
DCHECK(navigation_handle);
if (!web_contents_ || closing_ || stopped_) {
return;
}
// We want to honor the autoplay feature policy (via allow="autoplay") without
// explicit user activation, since media on Cast is extremely likely to have
// already been explicitly requested by a user via voice or over the network.
// By spoofing the "high media engagement" signal, we can bypass the user
// gesture requirement for autoplay.
int32_t autoplay_flags = blink::mojom::kAutoplayFlagHighMediaEngagement;
// Main frames should have autoplay enabled by default, since autoplay
// delegation via parent frame doesn't work here.
if (navigation_handle->IsInMainFrame()) {
autoplay_flags |= blink::mojom::kAutoplayFlagForceAllow;
}
mojo::AssociatedRemote<blink::mojom::AutoplayConfigurationClient> client;
navigation_handle->GetRenderFrameHost()
->GetRemoteAssociatedInterfaces()
->GetInterface(&client);
auto autoplay_origin = url::Origin::Create(navigation_handle->GetURL());
client->AddAutoplayFlags(autoplay_origin, autoplay_flags);
// Skip injecting bindings scripts if |navigation_handle| is not
// 'current' main frame navigation, e.g. another DidStartNavigation is
// emitted. Also skip injecting for same document navigation and error page.
if (navigation_handle == active_navigation_ &&
!navigation_handle->IsErrorPage()) {
// Injects registered bindings script into the main frame.
script_injector_.InjectScriptsForURL(
navigation_handle->GetURL(), navigation_handle->GetRenderFrameHost());
}
// Always allow mixed content (https and http in the same page) for cast.
// TODO(https://crbug.com/333795270): Decide whether to use
// kKeyAllowInsecureContent to configure allowing mixed content.
auto content_settings = blink::CreateDefaultRendererContentSettings();
content_settings->allow_mixed_content = true;
navigation_handle->SetContentSettings(std::move(content_settings));
// Notifies observers that the navigation of the main frame is ready.
for (Observer& observer : sync_observers_) {
observer.MainFrameReadyToCommitNavigation(navigation_handle);
}
}
void CastWebContentsImpl::DidFinishNavigation(
content::NavigationHandle* navigation_handle) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Ignore sub-frame and non-current main frame navigation.
if (navigation_handle != active_navigation_) {
return;
}
active_navigation_ = nullptr;
// If the navigation was not committed, it means either the page was a
// download or error 204/205, or the navigation never left the previous
// URL. Ignore these navigations.
if (!navigation_handle->HasCommitted()) {
LOG(WARNING) << "Navigation did not commit: url="
<< navigation_handle->GetURL();
return;
}
if (navigation_handle->IsErrorPage()) {
const net::Error error_code = navigation_handle->GetNetErrorCode();
LOG(ERROR) << "Got error on navigation: url=" << navigation_handle->GetURL()
<< ", error_code=" << error_code
<< ", description=" << net::ErrorToShortString(error_code);
Stop(error_code);
DCHECK_EQ(page_state_, PageState::ERROR);
}
// Notifies observers that the navigation of the main frame has finished
// with no errors.
for (auto& observer : observers_) {
observer->MainFrameFinishedNavigation();
}
}
void CastWebContentsImpl::DidFinishLoad(
content::RenderFrameHost* render_frame_host,
const GURL& validated_url) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (page_state_ != PageState::LOADING || !web_contents_ ||
render_frame_host != web_contents_->GetPrimaryMainFrame()) {
return;
}
// Don't process load completion on the current document if the WebContents
// is already in the process of navigating to a different page.
if (active_navigation_) {
return;
}
// The main frame finished loading. Before proceeding, we need to verify that
// the loaded page is the one that was requested.
TracePageLoadEnd(validated_url);
int http_status_code = 0;
content::NavigationEntry* nav_entry =
web_contents()->GetController().GetVisibleEntry();
if (nav_entry) {
http_status_code = nav_entry->GetHttpStatusCode();
}
if (http_status_code != 0 && http_status_code / 100 != 2) {
// An error HTML page was loaded instead of the content we requested.
LOG(ERROR) << "Failed loading page for: " << validated_url
<< "; http status code: " << http_status_code;
Stop(net::ERR_HTTP_RESPONSE_CODE_FAILURE);
DCHECK_EQ(page_state_, PageState::ERROR);
return;
}
// Main frame finished loading properly.
base::TimeDelta load_time = base::TimeTicks::Now() - start_loading_ticks_;
LOG(INFO) << "Finished loading page after " << load_time.InMilliseconds()
<< " ms, url=" << validated_url;
OnPageLoaded();
}
void CastWebContentsImpl::DidFailLoad(
content::RenderFrameHost* render_frame_host,
const GURL& validated_url,
int error_code) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Only report an error if we are the main frame. See b/8433611.
if (render_frame_host->GetParent()) {
LOG(ERROR) << "Got error on sub-iframe: url=" << validated_url.spec()
<< ", error=" << error_code;
return;
}
if (error_code == net::ERR_ABORTED) {
// ERR_ABORTED means download was aborted by the app, typically this happens
// when flinging URL for direct playback, the initial URLRequest gets
// cancelled/aborted and then the same URL is requested via the buffered
// data source for media::Pipeline playback.
LOG(INFO) << "Load canceled: url=" << validated_url.spec();
// We consider the page to be fully loaded in this case, since the app has
// intentionally entered this state. If the app wanted to stop, it would
// have called window.close() instead.
OnPageLoaded();
return;
}
LOG(ERROR) << "Got error on load: url=" << validated_url.spec()
<< ", error_code=" << error_code;
TracePageLoadEnd(validated_url);
Stop(error_code);
DCHECK_EQ(PageState::ERROR, page_state_);
}
void CastWebContentsImpl::OnPageLoading() {
closing_ = false;
stopped_ = false;
stop_notified_ = false;
main_frame_loaded_ = false;
last_error_ = net::OK;
}
void CastWebContentsImpl::OnPageLoaded() {
main_frame_loaded_ = true;
UpdatePageState();
DCHECK(page_state_ == PageState::LOADED);
NotifyPageState();
}
void CastWebContentsImpl::UpdatePageState() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
last_state_ = page_state_;
if (!web_contents_) {
DCHECK(stopped_);
page_state_ = PageState::DESTROYED;
} else if (!stopped_) {
if (main_frame_loaded_) {
page_state_ = PageState::LOADED;
} else {
page_state_ = PageState::LOADING;
}
} else if (stopped_) {
if (last_error_ != net::OK) {
page_state_ = PageState::ERROR;
} else {
page_state_ = PageState::CLOSED;
}
}
}
void CastWebContentsImpl::NotifyPageState() {
// Don't notify if the page state didn't change.
if (last_state_ == page_state_) {
return;
}
// Don't recursively notify the observers.
if (notifying_) {
return;
}
notifying_ = true;
if (stopped_ && !stop_notified_) {
stop_notified_ = true;
for (auto& observer : observers_) {
observer->PageStopped(page_state_, last_error_);
}
// Notifies the local observers.
for (Observer& observer : sync_observers_) {
observer.PageStopped(page_state_, last_error_);
}
} else {
for (auto& observer : observers_) {
observer->PageStateChanged(page_state_);
}
// Notifies the local observers.
for (Observer& observer : sync_observers_) {
observer.PageStateChanged(page_state_);
}
}
notifying_ = false;
}
void CastWebContentsImpl::ResourceLoadComplete(
content::RenderFrameHost* render_frame_host,
const content::GlobalRequestID& request_id,
const blink::mojom::ResourceLoadInfo& resource_load_info) {
if (!web_contents_ ||
render_frame_host != web_contents_->GetPrimaryMainFrame()) {
return;
}
int net_error = resource_load_info.net_error;
if (net_error == net::OK) {
return;
}
metrics::CastMetricsHelper* metrics_helper =
metrics::CastMetricsHelper::GetInstance();
metrics_helper->RecordApplicationEventWithValue(
"Cast.Platform.ResourceRequestError", net_error);
LOG(ERROR) << "Resource \"" << resource_load_info.original_url << "\""
<< " failed to load with net_error=" << net_error
<< ", description=" << net::ErrorToShortString(net_error);
shell::CastBrowserProcess::GetInstance()->connectivity_checker()->Check();
for (auto& observer : observers_) {
observer->ResourceLoadFailed();
}
}
void CastWebContentsImpl::InnerWebContentsCreated(
content::WebContents* inner_web_contents) {
if (!params_->handle_inner_contents) {
return;
}
mojom::CastWebViewParamsPtr params = mojom::CastWebViewParams::New();
params->enabled_for_dev = params_->enabled_for_dev;
params->background_color = params_->background_color;
auto result = inner_contents_.insert(std::unique_ptr<CastWebContentsImpl>(
new CastWebContentsImpl(inner_web_contents, std::move(params), this)));
// Notifies remote observers.
for (auto& observer : observers_) {
mojo::PendingRemote<mojom::CastWebContents> pending_remote;
result.first->get()->BindSharedReceiver(
pending_remote.InitWithNewPipeAndPassReceiver());
observer->InnerContentsCreated(std::move(pending_remote));
}
// Notifies the local observers.
for (Observer& observer : sync_observers_) {
observer.InnerContentsCreated(result.first->get(), this);
}
}
void CastWebContentsImpl::TitleWasSet(content::NavigationEntry* entry) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!entry) {
return;
}
for (auto& observer : observers_) {
observer->UpdateTitle(base::UTF16ToUTF8(entry->GetTitle()));
}
}
void CastWebContentsImpl::DidFirstVisuallyNonEmptyPaint() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
metrics::CastMetricsHelper::GetInstance()->LogTimeToFirstPaint();
for (auto& observer : observers_) {
observer->DidFirstVisuallyNonEmptyPaint();
}
}
void CastWebContentsImpl::WebContentsDestroyed() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
closing_ = false;
DisableDebugging();
media_blocker_.reset();
content::WebContentsObserver::Observe(nullptr);
web_contents_ = nullptr;
Stop(net::OK);
RemoveCastWebContents(this);
DCHECK_EQ(PageState::DESTROYED, page_state_);
}
void CastWebContentsImpl::DidUpdateFaviconURL(
content::RenderFrameHost* render_frame_host,
const std::vector<blink::mojom::FaviconURLPtr>& candidates) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (candidates.empty()) {
return;
}
GURL icon_url;
bool found_touch_icon = false;
// icon search order:
// 1) apple-touch-icon-precomposed
// 2) apple-touch-icon
// 3) icon
for (auto& favicon : candidates) {
if (favicon->icon_type ==
blink::mojom::FaviconIconType::kTouchPrecomposedIcon) {
icon_url = favicon->icon_url;
break;
} else if ((favicon->icon_type ==
blink::mojom::FaviconIconType::kTouchIcon) &&
!found_touch_icon) {
found_touch_icon = true;
icon_url = favicon->icon_url;
} else if (!found_touch_icon) {
icon_url = favicon->icon_url;
}
}
for (auto& observer : observers_) {
observer->UpdateFaviconURL(icon_url);
}
}
void CastWebContentsImpl::MediaStartedPlaying(
const MediaPlayerInfo& video_type,
const content::MediaPlayerId& id) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
metrics::CastMetricsHelper::GetInstance()->LogMediaPlay();
for (auto& observer : observers_) {
observer->MediaPlaybackChanged(true /* media_playing */);
}
// Notifies the local observers.
for (Observer& observer : sync_observers_) {
observer.MediaPlaybackChanged(true /* media_playing */);
}
}
void CastWebContentsImpl::MediaStoppedPlaying(
const MediaPlayerInfo& video_type,
const content::MediaPlayerId& id,
content::WebContentsObserver::MediaStoppedReason reason) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
metrics::CastMetricsHelper::GetInstance()->LogMediaPause();
for (auto& observer : observers_) {
observer->MediaPlaybackChanged(false /* media_playing */);
}
// Notifies the local observers.
for (Observer& observer : sync_observers_) {
observer.MediaPlaybackChanged(false /* media_playing */);
}
}
void CastWebContentsImpl::TracePageLoadBegin(const GURL& url) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(
"browser,navigation", "CastWebContentsImpl Launch", TRACE_ID_LOCAL(this),
"URL", url.possibly_invalid_spec());
}
void CastWebContentsImpl::TracePageLoadEnd(const GURL& url) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
TRACE_EVENT_NESTABLE_ASYNC_END1(
"browser,navigation", "CastWebContentsImpl Launch", TRACE_ID_LOCAL(this),
"URL", url.possibly_invalid_spec());
}
void CastWebContentsImpl::DisableDebugging() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!params_->enabled_for_dev || !web_contents_) {
return;
}
LOG(INFO) << "Disabling dev console for CastWebContentsImpl";
remote_debugging_server_->DisableWebContentsForDebugging(web_contents_);
}
} // namespace chromecast
Codebase Browser
chromium