blob: 997e1069caf5d2326f989e531069e26b2d1c0543 [file] [log] [blame]
// Copyright (c) 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.
#include "android_webview/browser/aw_content_browser_client.h"
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "android_webview/browser/aw_browser_context.h"
#include "android_webview/browser/aw_browser_main_parts.h"
#include "android_webview/browser/aw_content_browser_overlay_manifest.h"
#include "android_webview/browser/aw_content_renderer_overlay_manifest.h"
#include "android_webview/browser/aw_contents.h"
#include "android_webview/browser/aw_contents_client_bridge.h"
#include "android_webview/browser/aw_contents_io_thread_client.h"
#include "android_webview/browser/aw_cookie_access_policy.h"
#include "android_webview/browser/aw_devtools_manager_delegate.h"
#include "android_webview/browser/aw_feature_list.h"
#include "android_webview/browser/aw_feature_list_creator.h"
#include "android_webview/browser/aw_http_auth_handler.h"
#include "android_webview/browser/aw_quota_permission_context.h"
#include "android_webview/browser/aw_resource_context.h"
#include "android_webview/browser/aw_settings.h"
#include "android_webview/browser/aw_speech_recognition_manager_delegate.h"
#include "android_webview/browser/aw_web_contents_view_delegate.h"
#include "android_webview/browser/cookie_manager.h"
#include "android_webview/browser/js_java_interaction/js_api_handler_factory.h"
#include "android_webview/browser/network_service/aw_proxy_config_monitor.h"
#include "android_webview/browser/network_service/aw_proxying_restricted_cookie_manager.h"
#include "android_webview/browser/network_service/aw_proxying_url_loader_factory.h"
#include "android_webview/browser/network_service/aw_url_loader_throttle.h"
#include "android_webview/browser/safe_browsing/aw_url_checker_delegate_impl.h"
#include "android_webview/browser/tracing/aw_tracing_delegate.h"
#include "android_webview/common/aw_content_client.h"
#include "android_webview/common/aw_descriptors.h"
#include "android_webview/common/aw_switches.h"
#include "android_webview/common/js_java_interaction/interfaces.mojom.h"
#include "android_webview/common/render_view_messages.h"
#include "android_webview/common/url_constants.h"
#include "android_webview/grit/aw_resources.h"
#include "base/android/locale_utils.h"
#include "base/base_paths_android.h"
#include "base/base_switches.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/files/scoped_file.h"
#include "base/memory/ptr_util.h"
#include "base/path_service.h"
#include "base/stl_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/post_task.h"
#include "components/autofill/content/browser/content_autofill_driver_factory.h"
#include "components/cdm/browser/cdm_message_filter_android.h"
#include "components/cdm/browser/media_drm_storage_impl.h"
#include "components/content_capture/browser/content_capture_receiver_manager.h"
#include "components/crash/content/browser/crash_handler_host_linux.h"
#include "components/navigation_interception/intercept_navigation_delegate.h"
#include "components/policy/content/policy_blacklist_navigation_throttle.h"
#include "components/policy/core/browser/browser_policy_connector_base.h"
#include "components/prefs/pref_service.h"
#include "components/safe_browsing/browser/browser_url_loader_throttle.h"
#include "components/safe_browsing/browser/mojo_safe_browsing_impl.h"
#include "components/safe_browsing/features.h"
#include "components/spellcheck/spellcheck_buildflags.h"
#include "content/public/browser/browser_message_filter.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/child_process_security_policy.h"
#include "content/public/browser/client_certificate_delegate.h"
#include "content/public/browser/file_url_loader.h"
#include "content/public/browser/navigation_handle.h"
#include "content/public/browser/navigation_throttle.h"
#include "content/public/browser/network_service_instance.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/shared_cors_origin_access_list.h"
#include "content/public/browser/storage_partition.h"
#include "content/public/browser/web_contents.h"
#include "content/public/common/content_descriptors.h"
#include "content/public/common/content_features.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/service_names.mojom.h"
#include "content/public/common/url_constants.h"
#include "content/public/common/user_agent.h"
#include "content/public/common/web_preferences.h"
#include "media/mojo/buildflags.h"
#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "net/android/network_library.h"
#include "net/http/http_util.h"
#include "net/ssl/ssl_cert_request_info.h"
#include "net/ssl/ssl_info.h"
#include "services/network/network_service.h"
#include "services/network/public/cpp/resource_request.h"
#include "services/network/public/mojom/cookie_manager.mojom-forward.h"
#include "services/service_manager/public/cpp/binder_registry.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "storage/browser/quota/quota_settings.h"
#include "third_party/blink/public/common/loader/url_loader_throttle.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/base/resource/resource_bundle_android.h"
#include "ui/resources/grit/ui_resources.h"
#if BUILDFLAG(ENABLE_SPELLCHECK)
#include "components/spellcheck/browser/spell_check_host_impl.h"
#endif
using content::BrowserThread;
using content::ResourceType;
using content::WebContents;
namespace android_webview {
namespace {
static bool g_should_create_thread_pool = true;
#if DCHECK_IS_ON()
// A boolean value to determine if the NetworkContext has been created yet. This
// exists only to check correctness: g_check_cleartext_permitted may only be set
// before the NetworkContext has been created (otherwise,
// g_check_cleartext_permitted won't have any effect).
bool g_created_network_context_params = false;
#endif
// On apps targeting API level O or later, check cleartext is enforced.
bool g_check_cleartext_permitted = false;
// TODO(sgurun) move this to its own file.
// This class filters out incoming aw_contents related IPC messages for the
// renderer process on the IPC thread.
class AwContentsMessageFilter : public content::BrowserMessageFilter {
public:
explicit AwContentsMessageFilter(int process_id);
// BrowserMessageFilter methods.
void OverrideThreadForMessage(const IPC::Message& message,
BrowserThread::ID* thread) override;
bool OnMessageReceived(const IPC::Message& message) override;
void OnShouldOverrideUrlLoading(int routing_id,
const base::string16& url,
bool has_user_gesture,
bool is_redirect,
bool is_main_frame,
bool* ignore_navigation);
void OnSubFrameCreated(int parent_render_frame_id, int child_render_frame_id);
private:
~AwContentsMessageFilter() override;
int process_id_;
DISALLOW_COPY_AND_ASSIGN(AwContentsMessageFilter);
};
AwContentsMessageFilter::AwContentsMessageFilter(int process_id)
: BrowserMessageFilter(AndroidWebViewMsgStart),
process_id_(process_id) {
}
AwContentsMessageFilter::~AwContentsMessageFilter() {
}
void AwContentsMessageFilter::OverrideThreadForMessage(
const IPC::Message& message,
BrowserThread::ID* thread) {
if (message.type() == AwViewHostMsg_ShouldOverrideUrlLoading::ID) {
*thread = BrowserThread::UI;
}
}
bool AwContentsMessageFilter::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(AwContentsMessageFilter, message)
IPC_MESSAGE_HANDLER(AwViewHostMsg_ShouldOverrideUrlLoading,
OnShouldOverrideUrlLoading)
IPC_MESSAGE_HANDLER(AwViewHostMsg_SubFrameCreated, OnSubFrameCreated)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
void AwContentsMessageFilter::OnShouldOverrideUrlLoading(
int render_frame_id,
const base::string16& url,
bool has_user_gesture,
bool is_redirect,
bool is_main_frame,
bool* ignore_navigation) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
*ignore_navigation = false;
AwContentsClientBridge* client =
AwContentsClientBridge::FromID(process_id_, render_frame_id);
if (client) {
if (!client->ShouldOverrideUrlLoading(url, has_user_gesture, is_redirect,
is_main_frame, ignore_navigation)) {
// If the shouldOverrideUrlLoading call caused a java exception we should
// always return immediately here!
return;
}
} else {
LOG(WARNING) << "Failed to find the associated render view host for url: "
<< url;
}
}
void AwContentsMessageFilter::OnSubFrameCreated(int parent_render_frame_id,
int child_render_frame_id) {
AwContentsIoThreadClient::SubFrameCreated(process_id_, parent_render_frame_id,
child_render_frame_id);
}
// A dummy binder for mojo interface autofill::mojom::PasswordManagerDriver.
void DummyBindPasswordManagerDriver(
autofill::mojom::PasswordManagerDriverRequest request,
content::RenderFrameHost* render_frame_host) {}
void PassMojoCookieManagerToAwCookieManager(
CookieManager* cookie_manager,
const network::mojom::NetworkContextPtr& network_context) {
// Get the CookieManager from the NetworkContext.
mojo::PendingRemote<network::mojom::CookieManager> cookie_manager_remote;
network_context->GetCookieManager(
cookie_manager_remote.InitWithNewPipeAndPassReceiver());
// Pass the mojo::PendingRemote<network::mojom::CookieManager> to
// android_webview::CookieManager, so it can implement its APIs with this mojo
// CookieManager.
cookie_manager->SetMojoCookieManager(std::move(cookie_manager_remote));
}
#if BUILDFLAG(ENABLE_MOJO_CDM)
void CreateOriginId(cdm::MediaDrmStorageImpl::OriginIdObtainedCB callback) {
std::move(callback).Run(true, base::UnguessableToken::Create());
}
void AllowEmptyOriginIdCB(base::OnceCallback<void(bool)> callback) {
// Since CreateOriginId() always returns a non-empty origin ID, we don't need
// to allow empty origin ID.
std::move(callback).Run(false);
}
void CreateMediaDrmStorage(content::RenderFrameHost* render_frame_host,
::media::mojom::MediaDrmStorageRequest request) {
DCHECK(render_frame_host);
if (render_frame_host->GetLastCommittedOrigin().opaque()) {
DVLOG(1) << __func__ << ": Unique origin.";
return;
}
content::WebContents* web_contents =
content::WebContents::FromRenderFrameHost(render_frame_host);
DCHECK(web_contents) << "WebContents not available.";
auto* aw_browser_context =
static_cast<AwBrowserContext*>(web_contents->GetBrowserContext());
DCHECK(aw_browser_context) << "AwBrowserContext not available.";
PrefService* pref_service = aw_browser_context->GetPrefService();
DCHECK(pref_service);
// The object will be deleted on connection error, or when the frame navigates
// away.
new cdm::MediaDrmStorageImpl(
render_frame_host, pref_service, base::BindRepeating(&CreateOriginId),
base::BindRepeating(&AllowEmptyOriginIdCB), std::move(request));
}
#endif // BUILDFLAG(ENABLE_MOJO_CDM)
} // anonymous namespace
std::string GetProduct() {
return version_info::GetProductNameAndVersionForUserAgent();
}
std::string GetUserAgent() {
// "Version/4.0" had been hardcoded in the legacy WebView.
std::string product = "Version/4.0 " + GetProduct();
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kUseMobileUserAgent)) {
product += " Mobile";
}
return content::BuildUserAgentFromProductAndExtraOSInfo(
product, "; wv", true /* include_android_build_number */);
}
// TODO(yirui): can use similar logic as in PrependToAcceptLanguagesIfNecessary
// in chrome/browser/android/preferences/pref_service_bridge.cc
// static
std::string AwContentBrowserClient::GetAcceptLangsImpl() {
// Start with the current locale(s) in BCP47 format.
std::string locales_string = AwContents::GetLocaleList();
// If accept languages do not contain en-US, add in en-US which will be
// used with a lower q-value.
if (locales_string.find("en-US") == std::string::npos)
locales_string += ",en-US";
return locales_string;
}
// static
void AwContentBrowserClient::set_check_cleartext_permitted(bool permitted) {
#if DCHECK_IS_ON()
DCHECK(!g_created_network_context_params);
#endif
g_check_cleartext_permitted = permitted;
}
// static
bool AwContentBrowserClient::get_check_cleartext_permitted() {
return g_check_cleartext_permitted;
}
AwContentBrowserClient::AwContentBrowserClient(
AwFeatureListCreator* aw_feature_list_creator)
: aw_feature_list_creator_(aw_feature_list_creator) {
// |aw_feature_list_creator| should not be null. The AwBrowserContext will
// take the PrefService owned by the creator as the Local State instead
// of loading the JSON file from disk.
DCHECK(aw_feature_list_creator_);
// Although WebView does not support password manager feature, renderer code
// could still request this interface, so we register a dummy binder which
// just drops the incoming request, to avoid the 'Failed to locate a binder
// for interface' error log..
frame_interfaces_.AddInterface(
base::BindRepeating(&DummyBindPasswordManagerDriver));
sniff_file_urls_ = AwSettings::GetAllowSniffingFileUrls();
}
AwContentBrowserClient::~AwContentBrowserClient() {}
void AwContentBrowserClient::OnNetworkServiceCreated(
network::mojom::NetworkService* network_service) {
network::mojom::HttpAuthStaticParamsPtr auth_static_params =
network::mojom::HttpAuthStaticParams::New();
auth_static_params->supported_schemes = AwBrowserContext::GetAuthSchemes();
content::GetNetworkService()->SetUpHttpAuth(std::move(auth_static_params));
}
network::mojom::NetworkContextPtr AwContentBrowserClient::CreateNetworkContext(
content::BrowserContext* context,
bool in_memory,
const base::FilePath& relative_partition_path) {
DCHECK(context);
content::GetNetworkService()->ConfigureHttpAuthPrefs(
AwBrowserProcess::GetInstance()->CreateHttpAuthDynamicParams());
auto* aw_context = static_cast<AwBrowserContext*>(context);
network::mojom::NetworkContextPtr network_context;
network::mojom::NetworkContextParamsPtr context_params =
aw_context->GetNetworkContextParams(in_memory, relative_partition_path);
#if DCHECK_IS_ON()
g_created_network_context_params = true;
#endif
content::GetNetworkService()->CreateNetworkContext(
MakeRequest(&network_context), std::move(context_params));
// Pass a CookieManager to the code supporting AwCookieManager.java (i.e., the
// Cookies APIs).
PassMojoCookieManagerToAwCookieManager(aw_context->GetCookieManager(),
network_context);
return network_context;
}
AwBrowserContext* AwContentBrowserClient::InitBrowserContext() {
browser_context_ = std::make_unique<AwBrowserContext>();
return browser_context_.get();
}
std::unique_ptr<content::BrowserMainParts>
AwContentBrowserClient::CreateBrowserMainParts(
const content::MainFunctionParams& parameters) {
return std::make_unique<AwBrowserMainParts>(this);
}
content::WebContentsViewDelegate*
AwContentBrowserClient::GetWebContentsViewDelegate(
content::WebContents* web_contents) {
return AwWebContentsViewDelegate::Create(web_contents);
}
void AwContentBrowserClient::RenderProcessWillLaunch(
content::RenderProcessHost* host) {
// Grant content: scheme access to the whole renderer process, since we impose
// per-view access checks, and access is granted by default (see
// AwSettings.mAllowContentUrlAccess).
content::ChildProcessSecurityPolicy::GetInstance()->GrantRequestScheme(
host->GetID(), url::kContentScheme);
host->AddFilter(new AwContentsMessageFilter(host->GetID()));
// WebView always allows persisting data.
host->AddFilter(new cdm::CdmMessageFilterAndroid(true, false));
}
bool AwContentBrowserClient::ShouldUseMobileFlingCurve() {
return true;
}
bool AwContentBrowserClient::IsHandledURL(const GURL& url) {
if (!url.is_valid()) {
// We handle error cases.
return true;
}
const std::string scheme = url.scheme();
DCHECK_EQ(scheme, base::ToLowerASCII(scheme));
// See CreateJobFactory in aw_url_request_context_getter.cc for the
// list of protocols that are handled.
// TODO(mnaganov): Make this automatic.
static const char* const kProtocolList[] = {
url::kDataScheme,
url::kBlobScheme,
url::kFileSystemScheme,
content::kChromeUIScheme,
url::kContentScheme,
};
if (scheme == url::kFileScheme) {
// Return false for the "special" file URLs, so they can be loaded
// even if access to file: scheme is not granted to the child process.
return !IsAndroidSpecialFileUrl(url);
}
for (size_t i = 0; i < base::size(kProtocolList); ++i) {
if (scheme == kProtocolList[i])
return true;
}
return net::URLRequest::IsHandledProtocol(scheme);
}
bool AwContentBrowserClient::ForceSniffingFileUrlsForHtml() {
return sniff_file_urls_;
}
void AwContentBrowserClient::AppendExtraCommandLineSwitches(
base::CommandLine* command_line,
int child_process_id) {
if (!command_line->HasSwitch(switches::kSingleProcess)) {
// The only kind of a child process WebView can have is renderer or utility.
std::string process_type =
command_line->GetSwitchValueASCII(switches::kProcessType);
DCHECK(process_type == switches::kRendererProcess ||
process_type == switches::kUtilityProcess)
<< process_type;
// Pass crash reporter enabled state to renderer processes.
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
::switches::kEnableCrashReporter)) {
command_line->AppendSwitch(::switches::kEnableCrashReporter);
}
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
::switches::kEnableCrashReporterForTesting)) {
command_line->AppendSwitch(::switches::kEnableCrashReporterForTesting);
}
}
}
std::string AwContentBrowserClient::GetApplicationLocale() {
return base::android::GetDefaultLocaleString();
}
std::string AwContentBrowserClient::GetAcceptLangs(
content::BrowserContext* context) {
return GetAcceptLangsImpl();
}
gfx::ImageSkia AwContentBrowserClient::GetDefaultFavicon() {
ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
// TODO(boliu): Bundle our own default favicon?
return rb.GetImageNamed(IDR_DEFAULT_FAVICON).AsImageSkia();
}
bool AwContentBrowserClient::AllowAppCache(const GURL& manifest_url,
const GURL& first_party,
content::BrowserContext* context) {
// WebView doesn't have a per-site policy for locally stored data,
// instead AppCache can be disabled for individual WebViews.
return true;
}
scoped_refptr<content::QuotaPermissionContext>
AwContentBrowserClient::CreateQuotaPermissionContext() {
return new AwQuotaPermissionContext;
}
void AwContentBrowserClient::GetQuotaSettings(
content::BrowserContext* context,
content::StoragePartition* partition,
storage::OptionalQuotaSettingsCallback callback) {
storage::GetNominalDynamicSettings(
partition->GetPath(), context->IsOffTheRecord(),
storage::GetDefaultDiskInfoHelper(), std::move(callback));
}
content::GeneratedCodeCacheSettings
AwContentBrowserClient::GetGeneratedCodeCacheSettings(
content::BrowserContext* context) {
// If we pass 0 for size, disk_cache will pick a default size using the
// heuristics based on available disk size. These are implemented in
// disk_cache::PreferredCacheSize in net/disk_cache/cache_util.cc.
AwBrowserContext* browser_context = static_cast<AwBrowserContext*>(context);
return content::GeneratedCodeCacheSettings(true, 0,
browser_context->GetCacheDir());
}
void AwContentBrowserClient::AllowCertificateError(
content::WebContents* web_contents,
int cert_error,
const net::SSLInfo& ssl_info,
const GURL& request_url,
bool is_main_frame_request,
bool strict_enforcement,
const base::Callback<void(content::CertificateRequestResultType)>&
callback) {
AwContentsClientBridge* client =
AwContentsClientBridge::FromWebContents(web_contents);
bool cancel_request = true;
if (client)
client->AllowCertificateError(cert_error,
ssl_info.cert.get(),
request_url,
callback,
&cancel_request);
if (cancel_request)
callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
}
base::OnceClosure AwContentBrowserClient::SelectClientCertificate(
content::WebContents* web_contents,
net::SSLCertRequestInfo* cert_request_info,
net::ClientCertIdentityList client_certs,
std::unique_ptr<content::ClientCertificateDelegate> delegate) {
AwContentsClientBridge* client =
AwContentsClientBridge::FromWebContents(web_contents);
if (client)
client->SelectClientCertificate(cert_request_info, std::move(delegate));
return base::OnceClosure();
}
bool AwContentBrowserClient::CanCreateWindow(
content::RenderFrameHost* opener,
const GURL& opener_url,
const GURL& opener_top_level_frame_url,
const url::Origin& source_origin,
content::mojom::WindowContainerType container_type,
const GURL& target_url,
const content::Referrer& referrer,
const std::string& frame_name,
WindowOpenDisposition disposition,
const blink::mojom::WindowFeatures& features,
bool user_gesture,
bool opener_suppressed,
bool* no_javascript_access) {
// We unconditionally allow popup windows at this stage and will give
// the embedder the opporunity to handle displaying of the popup in
// WebContentsDelegate::AddContents (via the
// AwContentsClient.onCreateWindow callback).
// Note that if the embedder has blocked support for creating popup
// windows through AwSettings, then we won't get to this point as
// the popup creation will have been blocked at the WebKit level.
if (no_javascript_access) {
*no_javascript_access = false;
}
content::WebContents* web_contents =
content::WebContents::FromRenderFrameHost(opener);
AwSettings* settings = AwSettings::FromWebContents(web_contents);
return (settings && settings->GetJavaScriptCanOpenWindowsAutomatically()) ||
user_gesture;
}
base::FilePath AwContentBrowserClient::GetDefaultDownloadDirectory() {
// Android WebView does not currently use the Chromium downloads system.
// Download requests are cancelled immedately when recognized; see
// AwResourceDispatcherHost::CreateResourceHandlerForDownload. However the
// download system still tries to start up and calls this before recognizing
// the request has been cancelled.
return base::FilePath();
}
std::string AwContentBrowserClient::GetDefaultDownloadName() {
NOTREACHED() << "Android WebView does not use chromium downloads";
return std::string();
}
void AwContentBrowserClient::DidCreatePpapiPlugin(
content::BrowserPpapiHost* browser_host) {
NOTREACHED() << "Android WebView does not support plugins";
}
bool AwContentBrowserClient::AllowPepperSocketAPI(
content::BrowserContext* browser_context,
const GURL& url,
bool private_api,
const content::SocketPermissionRequest* params) {
NOTREACHED() << "Android WebView does not support plugins";
return false;
}
bool AwContentBrowserClient::IsPepperVpnProviderAPIAllowed(
content::BrowserContext* browser_context,
const GURL& url) {
NOTREACHED() << "Android WebView does not support plugins";
return false;
}
content::TracingDelegate* AwContentBrowserClient::GetTracingDelegate() {
return new AwTracingDelegate();
}
void AwContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
const base::CommandLine& command_line,
int child_process_id,
content::PosixFileDescriptorInfo* mappings) {
base::MemoryMappedFile::Region region;
int fd = ui::GetMainAndroidPackFd(&region);
mappings->ShareWithRegion(kAndroidWebViewMainPakDescriptor, fd, region);
fd = ui::GetCommonResourcesPackFd(&region);
mappings->ShareWithRegion(kAndroidWebView100PercentPakDescriptor, fd, region);
fd = ui::GetLocalePackFd(&region);
mappings->ShareWithRegion(kAndroidWebViewLocalePakDescriptor, fd, region);
int crash_signal_fd =
crashpad::CrashHandlerHost::Get()->GetDeathSignalSocket();
if (crash_signal_fd >= 0) {
mappings->Share(service_manager::kCrashDumpSignal, crash_signal_fd);
}
}
void AwContentBrowserClient::OverrideWebkitPrefs(
content::RenderViewHost* rvh,
content::WebPreferences* web_prefs) {
AwSettings* aw_settings = AwSettings::FromWebContents(
content::WebContents::FromRenderViewHost(rvh));
if (aw_settings) {
aw_settings->PopulateWebPreferences(web_prefs);
}
}
std::vector<std::unique_ptr<content::NavigationThrottle>>
AwContentBrowserClient::CreateThrottlesForNavigation(
content::NavigationHandle* navigation_handle) {
std::vector<std::unique_ptr<content::NavigationThrottle>> throttles;
// We allow intercepting only navigations within main frames. This
// is used to post onPageStarted. We handle shouldOverrideUrlLoading
// via a sync IPC.
if (navigation_handle->IsInMainFrame()) {
// Use Synchronous mode for the navigation interceptor, since this class
// doesn't actually call into an arbitrary client, it just posts a task to
// call onPageStarted. shouldOverrideUrlLoading happens earlier (see
// ContentBrowserClient::ShouldOverrideUrlLoading).
throttles.push_back(
navigation_interception::InterceptNavigationDelegate::CreateThrottleFor(
navigation_handle, navigation_interception::SynchronyMode::kSync));
throttles.push_back(std::make_unique<PolicyBlacklistNavigationThrottle>(
navigation_handle, AwBrowserContext::FromWebContents(
navigation_handle->GetWebContents())));
}
return throttles;
}
content::DevToolsManagerDelegate*
AwContentBrowserClient::GetDevToolsManagerDelegate() {
return new AwDevToolsManagerDelegate();
}
base::Optional<service_manager::Manifest>
AwContentBrowserClient::GetServiceManifestOverlay(base::StringPiece name) {
if (name == content::mojom::kBrowserServiceName)
return GetAWContentBrowserOverlayManifest();
if (name == content::mojom::kRendererServiceName)
return GetAWContentRendererOverlayManifest();
return base::nullopt;
}
void AwContentBrowserClient::BindInterfaceRequestFromFrame(
content::RenderFrameHost* render_frame_host,
const std::string& interface_name,
mojo::ScopedMessagePipeHandle interface_pipe) {
frame_interfaces_.TryBindInterface(interface_name, &interface_pipe,
render_frame_host);
}
bool AwContentBrowserClient::BindAssociatedInterfaceRequestFromFrame(
content::RenderFrameHost* render_frame_host,
const std::string& interface_name,
mojo::ScopedInterfaceEndpointHandle* handle) {
if (interface_name == autofill::mojom::AutofillDriver::Name_) {
autofill::ContentAutofillDriverFactory::BindAutofillDriver(
mojo::PendingAssociatedReceiver<autofill::mojom::AutofillDriver>(
std::move(*handle)),
render_frame_host);
return true;
}
if (interface_name == content_capture::mojom::ContentCaptureReceiver::Name_) {
content_capture::ContentCaptureReceiverManager::BindContentCaptureReceiver(
mojo::PendingAssociatedReceiver<
content_capture::mojom::ContentCaptureReceiver>(std::move(*handle)),
render_frame_host);
return true;
}
if (interface_name == mojom::JsToJavaMessaging::Name_) {
JsApiHandlerFactory::BindJsToJavaMessaging(
mojo::PendingAssociatedReceiver<mojom::JsToJavaMessaging>(
std::move(*handle)),
render_frame_host);
return true;
}
return false;
}
void AwContentBrowserClient::ExposeInterfacesToRenderer(
service_manager::BinderRegistry* registry,
blink::AssociatedInterfaceRegistry* associated_registry,
content::RenderProcessHost* render_process_host) {
content::ResourceContext* resource_context =
render_process_host->GetBrowserContext()->GetResourceContext();
registry->AddInterface(
base::BindRepeating(
&safe_browsing::MojoSafeBrowsingImpl::MaybeCreate,
render_process_host->GetID(), resource_context,
base::BindRepeating(
&AwContentBrowserClient::GetSafeBrowsingUrlCheckerDelegate,
base::Unretained(this))),
base::CreateSingleThreadTaskRunner({BrowserThread::IO}));
#if BUILDFLAG(ENABLE_SPELLCHECK)
registry->AddInterface(
base::BindRepeating(&SpellCheckHostImpl::Create),
base::CreateSingleThreadTaskRunner({BrowserThread::UI}));
#endif
}
std::vector<std::unique_ptr<blink::URLLoaderThrottle>>
AwContentBrowserClient::CreateURLLoaderThrottles(
const network::ResourceRequest& request,
content::BrowserContext* browser_context,
const base::RepeatingCallback<content::WebContents*()>& wc_getter,
content::NavigationUIData* navigation_ui_data,
int frame_tree_node_id) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
std::vector<std::unique_ptr<blink::URLLoaderThrottle>> result;
result.push_back(safe_browsing::BrowserURLLoaderThrottle::Create(
base::BindOnce(
[](AwContentBrowserClient* client, content::ResourceContext*) {
return client->GetSafeBrowsingUrlCheckerDelegate();
},
base::Unretained(this)),
wc_getter, frame_tree_node_id, browser_context->GetResourceContext()));
if (request.resource_type ==
static_cast<int>(content::ResourceType::kMainFrame)) {
const bool is_load_url =
request.transition_type & ui::PAGE_TRANSITION_FROM_API;
const bool is_go_back_forward =
request.transition_type & ui::PAGE_TRANSITION_FORWARD_BACK;
const bool is_reload = ui::PageTransitionCoreTypeIs(
static_cast<ui::PageTransition>(request.transition_type),
ui::PAGE_TRANSITION_RELOAD);
if (is_load_url || is_go_back_forward || is_reload) {
result.push_back(
std::make_unique<AwURLLoaderThrottle>(static_cast<AwResourceContext*>(
browser_context->GetResourceContext())));
}
}
return result;
}
scoped_refptr<safe_browsing::UrlCheckerDelegate>
AwContentBrowserClient::GetSafeBrowsingUrlCheckerDelegate() {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!safe_browsing_url_checker_delegate_) {
safe_browsing_url_checker_delegate_ = new AwUrlCheckerDelegateImpl(
AwBrowserProcess::GetInstance()->GetSafeBrowsingDBManager(),
AwBrowserProcess::GetInstance()->GetSafeBrowsingUIManager(),
AwBrowserProcess::GetInstance()->GetSafeBrowsingWhitelistManager());
}
return safe_browsing_url_checker_delegate_;
}
void AwContentBrowserClient::ExposeInterfacesToMediaService(
service_manager::BinderRegistry* registry,
content::RenderFrameHost* render_frame_host) {
#if BUILDFLAG(ENABLE_MOJO_CDM)
registry->AddInterface(
base::BindRepeating(&CreateMediaDrmStorage, render_frame_host));
#endif
}
bool AwContentBrowserClient::ShouldOverrideUrlLoading(
int frame_tree_node_id,
bool browser_initiated,
const GURL& gurl,
const std::string& request_method,
bool has_user_gesture,
bool is_redirect,
bool is_main_frame,
ui::PageTransition transition,
bool* ignore_navigation) {
*ignore_navigation = false;
// Only GETs can be overridden.
if (request_method != "GET")
return true;
bool application_initiated =
browser_initiated || transition & ui::PAGE_TRANSITION_FORWARD_BACK;
// Don't offer application-initiated navigations unless it's a redirect.
if (application_initiated && !is_redirect)
return true;
// For HTTP schemes, only top-level navigations can be overridden. Similarly,
// WebView Classic lets app override only top level about:blank navigations.
// So we filter out non-top about:blank navigations here.
//
// Note: about:blank navigations are not received in this path at the moment,
// they use the old SYNC IPC path as they are not handled by network stack.
// However, the old path should be removed in future.
if (!is_main_frame &&
(gurl.SchemeIs(url::kHttpScheme) || gurl.SchemeIs(url::kHttpsScheme) ||
gurl.SchemeIs(url::kAboutScheme)))
return true;
WebContents* web_contents =
WebContents::FromFrameTreeNodeId(frame_tree_node_id);
if (web_contents == nullptr)
return true;
AwContentsClientBridge* client_bridge =
AwContentsClientBridge::FromWebContents(web_contents);
if (client_bridge == nullptr)
return true;
base::string16 url = base::UTF8ToUTF16(gurl.possibly_invalid_spec());
return client_bridge->ShouldOverrideUrlLoading(
url, has_user_gesture, is_redirect, is_main_frame, ignore_navigation);
}
bool AwContentBrowserClient::ShouldCreateThreadPool() {
return g_should_create_thread_pool;
}
std::unique_ptr<content::LoginDelegate>
AwContentBrowserClient::CreateLoginDelegate(
const net::AuthChallengeInfo& auth_info,
content::WebContents* web_contents,
const content::GlobalRequestID& request_id,
bool is_main_frame,
const GURL& url,
scoped_refptr<net::HttpResponseHeaders> response_headers,
bool first_auth_attempt,
LoginAuthRequiredCallback auth_required_callback) {
return std::make_unique<AwHttpAuthHandler>(auth_info, web_contents,
first_auth_attempt,
std::move(auth_required_callback));
}
bool AwContentBrowserClient::HandleExternalProtocol(
const GURL& url,
content::WebContents::Getter web_contents_getter,
int child_id,
content::NavigationUIData* navigation_data,
bool is_main_frame,
ui::PageTransition page_transition,
bool has_user_gesture,
network::mojom::URLLoaderFactoryPtr* out_factory) {
auto request = mojo::MakeRequest(out_factory);
if (content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
// Manages its own lifetime.
new android_webview::AwProxyingURLLoaderFactory(0 /* process_id */,
std::move(request), nullptr,
true /* intercept_only */);
} else {
base::PostTask(FROM_HERE, {content::BrowserThread::IO},
base::BindOnce(
[](network::mojom::URLLoaderFactoryRequest request) {
// Manages its own lifetime.
new android_webview::AwProxyingURLLoaderFactory(
0 /* process_id */, std::move(request), nullptr,
true /* intercept_only */);
},
std::move(request)));
}
return false;
}
void AwContentBrowserClient::RegisterNonNetworkSubresourceURLLoaderFactories(
int render_process_id,
int render_frame_id,
NonNetworkURLLoaderFactoryMap* factories) {
WebContents* web_contents = content::WebContents::FromRenderFrameHost(
content::RenderFrameHost::FromID(render_process_id, render_frame_id));
AwSettings* aw_settings = AwSettings::FromWebContents(web_contents);
if (aw_settings && aw_settings->GetAllowFileAccess()) {
AwBrowserContext* aw_browser_context =
AwBrowserContext::FromWebContents(web_contents);
auto file_factory = CreateFileURLLoaderFactory(
aw_browser_context->GetPath(),
aw_browser_context->GetSharedCorsOriginAccessList());
factories->emplace(url::kFileScheme, std::move(file_factory));
}
}
bool AwContentBrowserClient::ShouldIsolateErrorPage(bool in_main_frame) {
return false;
}
bool AwContentBrowserClient::ShouldEnableStrictSiteIsolation() {
// TODO(lukasza): When/if we eventually add OOPIF support for AW we should
// consider running AW tests with and without site-per-process (and this might
// require returning true below). Adding OOPIF support for AW is tracked by
// https://crbug.com/869494.
return false;
}
bool AwContentBrowserClient::WillCreateURLLoaderFactory(
content::BrowserContext* browser_context,
content::RenderFrameHost* frame,
int render_process_id,
URLLoaderFactoryType type,
const url::Origin& request_initiator,
mojo::PendingReceiver<network::mojom::URLLoaderFactory>* factory_receiver,
mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient>*
header_client,
bool* bypass_redirect_checks) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
auto proxied_receiver = std::move(*factory_receiver);
network::mojom::URLLoaderFactoryPtrInfo target_factory_info;
*factory_receiver = mojo::MakeRequest(&target_factory_info);
int process_id =
type == URLLoaderFactoryType::kNavigation ? 0 : render_process_id;
// Android WebView has one non off-the-record browser context.
base::PostTask(FROM_HERE, {content::BrowserThread::IO},
base::BindOnce(&AwProxyingURLLoaderFactory::CreateProxy,
process_id, std::move(proxied_receiver),
std::move(target_factory_info)));
return true;
}
void AwContentBrowserClient::WillCreateURLLoaderFactoryForAppCacheSubresource(
int render_process_id,
mojo::PendingRemote<network::mojom::URLLoaderFactory>* pending_factory) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
auto pending_proxy = std::move(*pending_factory);
mojo::PendingReceiver<network::mojom::URLLoaderFactory> factory_receiver =
pending_factory->InitWithNewPipeAndPassReceiver();
base::PostTask(FROM_HERE, {content::BrowserThread::IO},
base::BindOnce(&AwProxyingURLLoaderFactory::CreateProxy,
render_process_id, std::move(factory_receiver),
std::move(pending_proxy)));
}
uint32_t AwContentBrowserClient::GetWebSocketOptions(
content::RenderFrameHost* frame) {
uint32_t options = network::mojom::kWebSocketOptionNone;
if (!frame) {
return options;
}
content::WebContents* web_contents =
content::WebContents::FromRenderFrameHost(frame);
AwContents* aw_contents = AwContents::FromWebContents(web_contents);
bool global_cookie_policy =
AwCookieAccessPolicy::GetInstance()->GetShouldAcceptCookies();
bool third_party_cookie_policy = aw_contents->AllowThirdPartyCookies();
if (!global_cookie_policy) {
options |= network::mojom::kWebSocketOptionBlockAllCookies;
} else if (!third_party_cookie_policy) {
options |= network::mojom::kWebSocketOptionBlockThirdPartyCookies;
}
return options;
}
bool AwContentBrowserClient::WillCreateRestrictedCookieManager(
network::mojom::RestrictedCookieManagerRole role,
content::BrowserContext* browser_context,
const url::Origin& origin,
bool is_service_worker,
int process_id,
int routing_id,
mojo::PendingReceiver<network::mojom::RestrictedCookieManager>* receiver) {
mojo::PendingReceiver<network::mojom::RestrictedCookieManager> orig_receiver =
std::move(*receiver);
mojo::PendingRemote<network::mojom::RestrictedCookieManager>
target_rcm_remote;
*receiver = target_rcm_remote.InitWithNewPipeAndPassReceiver();
AwProxyingRestrictedCookieManager::CreateAndBind(
std::move(target_rcm_remote), is_service_worker, process_id, routing_id,
std::move(orig_receiver));
return false; // only made a proxy, still need the actual impl to be made.
}
std::string AwContentBrowserClient::GetProduct() {
return android_webview::GetProduct();
}
std::string AwContentBrowserClient::GetUserAgent() {
return android_webview::GetUserAgent();
}
content::ContentBrowserClient::WideColorGamutHeuristic
AwContentBrowserClient::GetWideColorGamutHeuristic() {
if (base::FeatureList::IsEnabled(features::kWebViewWideColorGamutSupport))
return WideColorGamutHeuristic::kUseWindow;
return WideColorGamutHeuristic::kNone;
}
content::SpeechRecognitionManagerDelegate*
AwContentBrowserClient::CreateSpeechRecognitionManagerDelegate() {
return new AwSpeechRecognitionManagerDelegate();
}
// static
void AwContentBrowserClient::DisableCreatingThreadPool() {
g_should_create_thread_pool = false;
}
} // namespace android_webview