1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "android_webview/browser/aw_content_browser_client.h"
6 
7 #include <memory>
8 #include <string>
9 #include <utility>
10 #include <vector>
11 
12 #include "android_webview/browser/aw_browser_context.h"
13 #include "android_webview/browser/aw_browser_main_parts.h"
14 #include "android_webview/browser/aw_contents.h"
15 #include "android_webview/browser/aw_contents_client_bridge.h"
16 #include "android_webview/browser/aw_contents_io_thread_client.h"
17 #include "android_webview/browser/aw_cookie_access_policy.h"
18 #include "android_webview/browser/aw_devtools_manager_delegate.h"
19 #include "android_webview/browser/aw_feature_list_creator.h"
20 #include "android_webview/browser/aw_http_auth_handler.h"
21 #include "android_webview/browser/aw_quota_permission_context.h"
22 #include "android_webview/browser/aw_resource_context.h"
23 #include "android_webview/browser/aw_settings.h"
24 #include "android_webview/browser/aw_speech_recognition_manager_delegate.h"
25 #include "android_webview/browser/aw_web_contents_view_delegate.h"
26 #include "android_webview/browser/cookie_manager.h"
27 #include "android_webview/browser/network_service/aw_proxy_config_monitor.h"
28 #include "android_webview/browser/network_service/aw_proxying_restricted_cookie_manager.h"
29 #include "android_webview/browser/network_service/aw_proxying_url_loader_factory.h"
30 #include "android_webview/browser/network_service/aw_url_loader_throttle.h"
31 #include "android_webview/browser/safe_browsing/aw_safe_browsing_navigation_throttle.h"
32 #include "android_webview/browser/safe_browsing/aw_url_checker_delegate_impl.h"
33 #include "android_webview/browser/tracing/aw_tracing_delegate.h"
34 #include "android_webview/common/aw_content_client.h"
35 #include "android_webview/common/aw_descriptors.h"
36 #include "android_webview/common/aw_features.h"
37 #include "android_webview/common/aw_switches.h"
38 #include "android_webview/common/render_view_messages.h"
39 #include "android_webview/common/url_constants.h"
40 #include "base/android/locale_utils.h"
41 #include "base/base_paths_android.h"
42 #include "base/base_switches.h"
43 #include "base/bind.h"
44 #include "base/callback_helpers.h"
45 #include "base/command_line.h"
46 #include "base/feature_list.h"
47 #include "base/files/scoped_file.h"
48 #include "base/memory/ptr_util.h"
49 #include "base/path_service.h"
50 #include "base/stl_util.h"
51 #include "base/strings/utf_string_conversions.h"
52 #include "build/build_config.h"
53 #include "components/autofill/content/browser/content_autofill_driver_factory.h"
54 #include "components/cdm/browser/cdm_message_filter_android.h"
55 #include "components/content_capture/browser/content_capture_receiver_manager.h"
56 #include "components/crash/content/browser/crash_handler_host_linux.h"
57 #include "components/navigation_interception/intercept_navigation_delegate.h"
58 #include "components/page_load_metrics/browser/metrics_navigation_throttle.h"
59 #include "components/page_load_metrics/browser/metrics_web_contents_observer.h"
60 #include "components/policy/content/policy_blocklist_navigation_throttle.h"
61 #include "components/policy/core/browser/browser_policy_connector_base.h"
62 #include "components/prefs/pref_service.h"
63 #include "components/safe_browsing/content/browser/browser_url_loader_throttle.h"
64 #include "components/safe_browsing/content/browser/mojo_safe_browsing_impl.h"
65 #include "components/safe_browsing/core/features.h"
66 #include "components/spellcheck/spellcheck_buildflags.h"
67 #include "content/public/browser/browser_message_filter.h"
68 #include "content/public/browser/browser_task_traits.h"
69 #include "content/public/browser/browser_thread.h"
70 #include "content/public/browser/child_process_security_policy.h"
71 #include "content/public/browser/client_certificate_delegate.h"
72 #include "content/public/browser/file_url_loader.h"
73 #include "content/public/browser/navigation_handle.h"
74 #include "content/public/browser/navigation_throttle.h"
75 #include "content/public/browser/network_service_instance.h"
76 #include "content/public/browser/render_frame_host.h"
77 #include "content/public/browser/render_process_host.h"
78 #include "content/public/browser/render_view_host.h"
79 #include "content/public/browser/shared_cors_origin_access_list.h"
80 #include "content/public/browser/storage_partition.h"
81 #include "content/public/browser/web_contents.h"
82 #include "content/public/common/content_descriptors.h"
83 #include "content/public/common/content_features.h"
84 #include "content/public/common/content_switches.h"
85 #include "content/public/common/service_names.mojom.h"
86 #include "content/public/common/url_constants.h"
87 #include "content/public/common/user_agent.h"
88 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
89 #include "mojo/public/cpp/bindings/pending_receiver.h"
90 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
91 #include "net/android/network_library.h"
92 #include "net/http/http_util.h"
93 #include "net/net_buildflags.h"
94 #include "net/ssl/ssl_cert_request_info.h"
95 #include "net/ssl/ssl_info.h"
96 #include "services/metrics/public/cpp/ukm_source_id.h"
97 #include "services/network/network_service.h"
98 #include "services/network/public/cpp/resource_request.h"
99 #include "services/network/public/mojom/cookie_manager.mojom-forward.h"
100 #include "services/service_manager/public/cpp/binder_registry.h"
101 #include "services/service_manager/public/cpp/interface_provider.h"
102 #include "third_party/blink/public/common/loader/url_loader_throttle.h"
103 #include "third_party/blink/public/common/web_preferences/web_preferences.h"
104 #include "third_party/blink/public/mojom/loader/resource_load_info.mojom-shared.h"
105 #include "ui/base/resource/resource_bundle.h"
106 #include "ui/base/resource/resource_bundle_android.h"
107 #include "ui/display/display.h"
108 #include "ui/resources/grit/ui_resources.h"
109 
110 #if BUILDFLAG(ENABLE_SPELLCHECK)
111 #include "components/spellcheck/browser/spell_check_host_impl.h"
112 #endif
113 
114 using content::BrowserThread;
115 using content::WebContents;
116 
117 namespace android_webview {
118 namespace {
119 static bool g_should_create_thread_pool = true;
120 #if DCHECK_IS_ON()
121 // A boolean value to determine if the NetworkContext has been created yet. This
122 // exists only to check correctness: g_check_cleartext_permitted may only be set
123 // before the NetworkContext has been created (otherwise,
124 // g_check_cleartext_permitted won't have any effect).
125 bool g_created_network_context_params = false;
126 #endif
127 
128 // On apps targeting API level O or later, check cleartext is enforced.
129 bool g_check_cleartext_permitted = false;
130 
131 // TODO(sgurun) move this to its own file.
132 // This class filters out incoming aw_contents related IPC messages for the
133 // renderer process on the IPC thread.
134 class AwContentsMessageFilter : public content::BrowserMessageFilter {
135  public:
136   explicit AwContentsMessageFilter(int process_id);
137 
138   // BrowserMessageFilter methods.
139   void OverrideThreadForMessage(const IPC::Message& message,
140                                 BrowserThread::ID* thread) override;
141   bool OnMessageReceived(const IPC::Message& message) override;
142 
143   void OnShouldOverrideUrlLoading(int routing_id,
144                                   const base::string16& url,
145                                   bool has_user_gesture,
146                                   bool is_redirect,
147                                   bool is_main_frame,
148                                   bool* ignore_navigation);
149   void OnSubFrameCreated(int parent_render_frame_id, int child_render_frame_id);
150 
151  private:
152   ~AwContentsMessageFilter() override;
153 
154   int process_id_;
155 
156   DISALLOW_COPY_AND_ASSIGN(AwContentsMessageFilter);
157 };
158 
AwContentsMessageFilter(int process_id)159 AwContentsMessageFilter::AwContentsMessageFilter(int process_id)
160     : BrowserMessageFilter(AndroidWebViewMsgStart), process_id_(process_id) {}
161 
162 AwContentsMessageFilter::~AwContentsMessageFilter() = default;
163 
OverrideThreadForMessage(const IPC::Message & message,BrowserThread::ID * thread)164 void AwContentsMessageFilter::OverrideThreadForMessage(
165     const IPC::Message& message,
166     BrowserThread::ID* thread) {
167   if (message.type() == AwViewHostMsg_ShouldOverrideUrlLoading::ID) {
168     *thread = BrowserThread::UI;
169   }
170 }
171 
OnMessageReceived(const IPC::Message & message)172 bool AwContentsMessageFilter::OnMessageReceived(const IPC::Message& message) {
173   bool handled = true;
174   IPC_BEGIN_MESSAGE_MAP(AwContentsMessageFilter, message)
175     IPC_MESSAGE_HANDLER(AwViewHostMsg_ShouldOverrideUrlLoading,
176                         OnShouldOverrideUrlLoading)
177     IPC_MESSAGE_HANDLER(AwViewHostMsg_SubFrameCreated, OnSubFrameCreated)
178     IPC_MESSAGE_UNHANDLED(handled = false)
179   IPC_END_MESSAGE_MAP()
180   return handled;
181 }
182 
OnShouldOverrideUrlLoading(int render_frame_id,const base::string16 & url,bool has_user_gesture,bool is_redirect,bool is_main_frame,bool * ignore_navigation)183 void AwContentsMessageFilter::OnShouldOverrideUrlLoading(
184     int render_frame_id,
185     const base::string16& url,
186     bool has_user_gesture,
187     bool is_redirect,
188     bool is_main_frame,
189     bool* ignore_navigation) {
190   DCHECK_CURRENTLY_ON(BrowserThread::UI);
191   *ignore_navigation = false;
192   AwContentsClientBridge* client =
193       AwContentsClientBridge::FromID(process_id_, render_frame_id);
194   if (client) {
195     if (!client->ShouldOverrideUrlLoading(url, has_user_gesture, is_redirect,
196                                           is_main_frame, ignore_navigation)) {
197       // If the shouldOverrideUrlLoading call caused a java exception we should
198       // always return immediately here!
199       return;
200     }
201   } else {
202     LOG(WARNING) << "Failed to find the associated render view host for url: "
203                  << url;
204   }
205 }
206 
OnSubFrameCreated(int parent_render_frame_id,int child_render_frame_id)207 void AwContentsMessageFilter::OnSubFrameCreated(int parent_render_frame_id,
208                                                 int child_render_frame_id) {
209   AwContentsIoThreadClient::SubFrameCreated(process_id_, parent_render_frame_id,
210                                             child_render_frame_id);
211 }
212 
213 // Helper method that checks the RenderProcessHost is still alive before hopping
214 // over to the IO thread.
MaybeCreateSafeBrowsing(int rph_id,content::ResourceContext * resource_context,base::RepeatingCallback<scoped_refptr<safe_browsing::UrlCheckerDelegate> ()> get_checker_delegate,mojo::PendingReceiver<safe_browsing::mojom::SafeBrowsing> receiver)215 void MaybeCreateSafeBrowsing(
216     int rph_id,
217     content::ResourceContext* resource_context,
218     base::RepeatingCallback<scoped_refptr<safe_browsing::UrlCheckerDelegate>()>
219         get_checker_delegate,
220     mojo::PendingReceiver<safe_browsing::mojom::SafeBrowsing> receiver) {
221   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
222 
223   content::RenderProcessHost* render_process_host =
224       content::RenderProcessHost::FromID(rph_id);
225   if (!render_process_host)
226     return;
227 
228   content::GetIOThreadTaskRunner({})->PostTask(
229       FROM_HERE,
230       base::BindOnce(&safe_browsing::MojoSafeBrowsingImpl::MaybeCreate, rph_id,
231                      resource_context, std::move(get_checker_delegate),
232                      std::move(receiver)));
233 }
234 
235 }  // anonymous namespace
236 
GetProduct()237 std::string GetProduct() {
238   return version_info::GetProductNameAndVersionForUserAgent();
239 }
240 
GetUserAgent()241 std::string GetUserAgent() {
242   // "Version/4.0" had been hardcoded in the legacy WebView.
243   std::string product = "Version/4.0 " + GetProduct();
244   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
245           switches::kUseMobileUserAgent)) {
246     product += " Mobile";
247   }
248   return content::BuildUserAgentFromProductAndExtraOSInfo(
249       product, "; wv", content::IncludeAndroidBuildNumber::Include);
250 }
251 
252 // TODO(yirui): can use similar logic as in PrependToAcceptLanguagesIfNecessary
253 // in chrome/browser/android/preferences/pref_service_bridge.cc
254 // static
GetAcceptLangsImpl()255 std::string AwContentBrowserClient::GetAcceptLangsImpl() {
256   // Start with the current locale(s) in BCP47 format.
257   std::string locales_string = AwContents::GetLocaleList();
258 
259   // If accept languages do not contain en-US, add in en-US which will be
260   // used with a lower q-value.
261   if (locales_string.find("en-US") == std::string::npos)
262     locales_string += ",en-US";
263   return locales_string;
264 }
265 
266 // static
set_check_cleartext_permitted(bool permitted)267 void AwContentBrowserClient::set_check_cleartext_permitted(bool permitted) {
268 #if DCHECK_IS_ON()
269   DCHECK(!g_created_network_context_params);
270 #endif
271   g_check_cleartext_permitted = permitted;
272 }
273 
274 // static
get_check_cleartext_permitted()275 bool AwContentBrowserClient::get_check_cleartext_permitted() {
276   return g_check_cleartext_permitted;
277 }
278 
AwContentBrowserClient(AwFeatureListCreator * aw_feature_list_creator)279 AwContentBrowserClient::AwContentBrowserClient(
280     AwFeatureListCreator* aw_feature_list_creator)
281     : sniff_file_urls_(AwSettings::GetAllowSniffingFileUrls()),
282       aw_feature_list_creator_(aw_feature_list_creator) {
283   // |aw_feature_list_creator| should not be null. The AwBrowserContext will
284   // take the PrefService owned by the creator as the Local State instead
285   // of loading the JSON file from disk.
286   DCHECK(aw_feature_list_creator_);
287 }
288 
~AwContentBrowserClient()289 AwContentBrowserClient::~AwContentBrowserClient() {}
290 
OnNetworkServiceCreated(network::mojom::NetworkService * network_service)291 void AwContentBrowserClient::OnNetworkServiceCreated(
292     network::mojom::NetworkService* network_service) {
293   network::mojom::HttpAuthStaticParamsPtr auth_static_params =
294       network::mojom::HttpAuthStaticParams::New();
295   auth_static_params->supported_schemes = AwBrowserContext::GetAuthSchemes();
296   content::GetNetworkService()->SetUpHttpAuth(std::move(auth_static_params));
297 }
298 
ConfigureNetworkContextParams(content::BrowserContext * context,bool in_memory,const base::FilePath & relative_partition_path,network::mojom::NetworkContextParams * network_context_params,network::mojom::CertVerifierCreationParams * cert_verifier_creation_params)299 void AwContentBrowserClient::ConfigureNetworkContextParams(
300     content::BrowserContext* context,
301     bool in_memory,
302     const base::FilePath& relative_partition_path,
303     network::mojom::NetworkContextParams* network_context_params,
304     network::mojom::CertVerifierCreationParams* cert_verifier_creation_params) {
305   DCHECK(context);
306 
307   content::GetNetworkService()->ConfigureHttpAuthPrefs(
308       AwBrowserProcess::GetInstance()->CreateHttpAuthDynamicParams());
309 
310   AwBrowserContext* aw_context = static_cast<AwBrowserContext*>(context);
311   aw_context->ConfigureNetworkContextParams(in_memory, relative_partition_path,
312                                             network_context_params,
313                                             cert_verifier_creation_params);
314 
315   mojo::PendingRemote<network::mojom::CookieManager> cookie_manager_remote;
316   network_context_params->cookie_manager =
317       cookie_manager_remote.InitWithNewPipeAndPassReceiver();
318 
319 #if DCHECK_IS_ON()
320   g_created_network_context_params = true;
321 #endif
322 
323   // Pass the mojo::PendingRemote<network::mojom::CookieManager> to
324   // android_webview::CookieManager, so it can implement its APIs with this mojo
325   // CookieManager.
326   aw_context->GetCookieManager()->SetMojoCookieManager(
327       std::move(cookie_manager_remote));
328 }
329 
InitBrowserContext()330 AwBrowserContext* AwContentBrowserClient::InitBrowserContext() {
331   browser_context_ = std::make_unique<AwBrowserContext>();
332   return browser_context_.get();
333 }
334 
335 std::unique_ptr<content::BrowserMainParts>
CreateBrowserMainParts(const content::MainFunctionParams & parameters)336 AwContentBrowserClient::CreateBrowserMainParts(
337     const content::MainFunctionParams& parameters) {
338   return std::make_unique<AwBrowserMainParts>(this);
339 }
340 
341 content::WebContentsViewDelegate*
GetWebContentsViewDelegate(content::WebContents * web_contents)342 AwContentBrowserClient::GetWebContentsViewDelegate(
343     content::WebContents* web_contents) {
344   return AwWebContentsViewDelegate::Create(web_contents);
345 }
346 
RenderProcessWillLaunch(content::RenderProcessHost * host)347 void AwContentBrowserClient::RenderProcessWillLaunch(
348     content::RenderProcessHost* host) {
349   // Grant content: scheme access to the whole renderer process, since we impose
350   // per-view access checks, and access is granted by default (see
351   // AwSettings.mAllowContentUrlAccess).
352   content::ChildProcessSecurityPolicy::GetInstance()->GrantRequestScheme(
353       host->GetID(), url::kContentScheme);
354 
355   host->AddFilter(new AwContentsMessageFilter(host->GetID()));
356   // WebView always allows persisting data.
357   host->AddFilter(new cdm::CdmMessageFilterAndroid(true, false));
358 }
359 
IsExplicitNavigation(ui::PageTransition transition)360 bool AwContentBrowserClient::IsExplicitNavigation(
361     ui::PageTransition transition) {
362   return ui::PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_TYPED);
363 }
364 
IsHandledURL(const GURL & url)365 bool AwContentBrowserClient::IsHandledURL(const GURL& url) {
366   if (!url.is_valid()) {
367     // We handle error cases.
368     return true;
369   }
370 
371   const std::string scheme = url.scheme();
372   DCHECK_EQ(scheme, base::ToLowerASCII(scheme));
373   static const char* const kProtocolList[] = {
374     url::kHttpScheme,
375     url::kHttpsScheme,
376 #if BUILDFLAG(ENABLE_WEBSOCKETS)
377     url::kWsScheme,
378     url::kWssScheme,
379 #endif  // BUILDFLAG(ENABLE_WEBSOCKETS)
380     url::kDataScheme,
381     url::kBlobScheme,
382     url::kFileSystemScheme,
383     content::kChromeUIScheme,
384     url::kContentScheme,
385   };
386   if (scheme == url::kFileScheme) {
387     // Return false for the "special" file URLs, so they can be loaded
388     // even if access to file: scheme is not granted to the child process.
389     return !IsAndroidSpecialFileUrl(url);
390   }
391   for (const char* supported_protocol : kProtocolList) {
392     if (scheme == supported_protocol)
393       return true;
394   }
395   return false;
396 }
397 
ForceSniffingFileUrlsForHtml()398 bool AwContentBrowserClient::ForceSniffingFileUrlsForHtml() {
399   return sniff_file_urls_;
400 }
401 
AppendExtraCommandLineSwitches(base::CommandLine * command_line,int child_process_id)402 void AwContentBrowserClient::AppendExtraCommandLineSwitches(
403     base::CommandLine* command_line,
404     int child_process_id) {
405   // AppCache should always be enabled for WebView until it is removed.
406   command_line->AppendSwitch(switches::kAppCacheForceEnabled);
407 
408   if (!command_line->HasSwitch(switches::kSingleProcess)) {
409     // The only kind of a child process WebView can have is renderer or utility.
410     std::string process_type =
411         command_line->GetSwitchValueASCII(switches::kProcessType);
412     DCHECK(process_type == switches::kRendererProcess ||
413            process_type == switches::kUtilityProcess)
414         << process_type;
415     // Pass crash reporter enabled state to renderer processes.
416     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
417             ::switches::kEnableCrashReporter)) {
418       command_line->AppendSwitch(::switches::kEnableCrashReporter);
419     }
420     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
421             ::switches::kEnableCrashReporterForTesting)) {
422       command_line->AppendSwitch(::switches::kEnableCrashReporterForTesting);
423     }
424   }
425 }
426 
GetApplicationLocale()427 std::string AwContentBrowserClient::GetApplicationLocale() {
428   return base::android::GetDefaultLocaleString();
429 }
430 
GetAcceptLangs(content::BrowserContext * context)431 std::string AwContentBrowserClient::GetAcceptLangs(
432     content::BrowserContext* context) {
433   return GetAcceptLangsImpl();
434 }
435 
GetDefaultFavicon()436 gfx::ImageSkia AwContentBrowserClient::GetDefaultFavicon() {
437   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
438   // TODO(boliu): Bundle our own default favicon?
439   return rb.GetImageNamed(IDR_DEFAULT_FAVICON).AsImageSkia();
440 }
441 
AllowAppCache(const GURL & manifest_url,const GURL & site_for_cookies,const base::Optional<url::Origin> & top_frame_origin,content::BrowserContext * context)442 bool AwContentBrowserClient::AllowAppCache(
443     const GURL& manifest_url,
444     const GURL& site_for_cookies,
445     const base::Optional<url::Origin>& top_frame_origin,
446     content::BrowserContext* context) {
447   // WebView doesn't have a per-site policy for locally stored data,
448   // instead AppCache can be disabled for individual WebViews.
449   return true;
450 }
451 
452 scoped_refptr<content::QuotaPermissionContext>
CreateQuotaPermissionContext()453 AwContentBrowserClient::CreateQuotaPermissionContext() {
454   return new AwQuotaPermissionContext;
455 }
456 
457 content::GeneratedCodeCacheSettings
GetGeneratedCodeCacheSettings(content::BrowserContext * context)458 AwContentBrowserClient::GetGeneratedCodeCacheSettings(
459     content::BrowserContext* context) {
460   // WebView limits the main HTTP cache to 20MB; we need to set a comparable
461   // limit for the code cache since the source file needs to be in the HTTP
462   // cache for the code cache entry to be used. There are two code caches that
463   // both use this value, so we pass 10MB to keep the total disk usage to
464   // roughly 2x what it was before the code cache was implemented.
465   // TODO(crbug/893318): webview should have smarter cache sizing logic.
466   AwBrowserContext* browser_context = static_cast<AwBrowserContext*>(context);
467   return content::GeneratedCodeCacheSettings(true, 10 * 1024 * 1024,
468                                              browser_context->GetCacheDir());
469 }
470 
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,base::OnceCallback<void (content::CertificateRequestResultType)> callback)471 void AwContentBrowserClient::AllowCertificateError(
472     content::WebContents* web_contents,
473     int cert_error,
474     const net::SSLInfo& ssl_info,
475     const GURL& request_url,
476     bool is_main_frame_request,
477     bool strict_enforcement,
478     base::OnceCallback<void(content::CertificateRequestResultType)> callback) {
479   AwContentsClientBridge* client =
480       AwContentsClientBridge::FromWebContents(web_contents);
481   bool cancel_request = true;
482   // We only call the callback once but we must pass ownership to a function
483   // that conditionally calls it.
484   // TODO(estaab): Change AwContentsClientBridge::AllowCertificateError to
485   //               return the callback if it doesn't call it.
486   base::RepeatingCallback<void(content::CertificateRequestResultType)>
487       repeating_callback = base::AdaptCallbackForRepeating(std::move(callback));
488   if (client) {
489     client->AllowCertificateError(cert_error, ssl_info.cert.get(), request_url,
490                                   base::BindOnce(repeating_callback),
491                                   &cancel_request);
492   }
493   if (cancel_request) {
494     repeating_callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
495   }
496 }
497 
SelectClientCertificate(content::WebContents * web_contents,net::SSLCertRequestInfo * cert_request_info,net::ClientCertIdentityList client_certs,std::unique_ptr<content::ClientCertificateDelegate> delegate)498 base::OnceClosure AwContentBrowserClient::SelectClientCertificate(
499     content::WebContents* web_contents,
500     net::SSLCertRequestInfo* cert_request_info,
501     net::ClientCertIdentityList client_certs,
502     std::unique_ptr<content::ClientCertificateDelegate> delegate) {
503   AwContentsClientBridge* client =
504       AwContentsClientBridge::FromWebContents(web_contents);
505   if (client)
506     client->SelectClientCertificate(cert_request_info, std::move(delegate));
507   return base::OnceClosure();
508 }
509 
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)510 bool AwContentBrowserClient::CanCreateWindow(
511     content::RenderFrameHost* opener,
512     const GURL& opener_url,
513     const GURL& opener_top_level_frame_url,
514     const url::Origin& source_origin,
515     content::mojom::WindowContainerType container_type,
516     const GURL& target_url,
517     const content::Referrer& referrer,
518     const std::string& frame_name,
519     WindowOpenDisposition disposition,
520     const blink::mojom::WindowFeatures& features,
521     bool user_gesture,
522     bool opener_suppressed,
523     bool* no_javascript_access) {
524   // We unconditionally allow popup windows at this stage and will give
525   // the embedder the opporunity to handle displaying of the popup in
526   // WebContentsDelegate::AddContents (via the
527   // AwContentsClient.onCreateWindow callback).
528   // Note that if the embedder has blocked support for creating popup
529   // windows through AwSettings, then we won't get to this point as
530   // the popup creation will have been blocked at the WebKit level.
531   if (no_javascript_access) {
532     *no_javascript_access = false;
533   }
534 
535   content::WebContents* web_contents =
536       content::WebContents::FromRenderFrameHost(opener);
537   AwSettings* settings = AwSettings::FromWebContents(web_contents);
538 
539   return (settings && settings->GetJavaScriptCanOpenWindowsAutomatically()) ||
540          user_gesture;
541 }
542 
GetDefaultDownloadDirectory()543 base::FilePath AwContentBrowserClient::GetDefaultDownloadDirectory() {
544   // Android WebView does not currently use the Chromium downloads system.
545   // Download requests are cancelled immedately when recognized; see
546   // AwResourceDispatcherHost::CreateResourceHandlerForDownload. However the
547   // download system still tries to start up and calls this before recognizing
548   // the request has been cancelled.
549   return base::FilePath();
550 }
551 
GetDefaultDownloadName()552 std::string AwContentBrowserClient::GetDefaultDownloadName() {
553   NOTREACHED() << "Android WebView does not use chromium downloads";
554   return std::string();
555 }
556 
DidCreatePpapiPlugin(content::BrowserPpapiHost * browser_host)557 void AwContentBrowserClient::DidCreatePpapiPlugin(
558     content::BrowserPpapiHost* browser_host) {
559   NOTREACHED() << "Android WebView does not support plugins";
560 }
561 
AllowPepperSocketAPI(content::BrowserContext * browser_context,const GURL & url,bool private_api,const content::SocketPermissionRequest * params)562 bool AwContentBrowserClient::AllowPepperSocketAPI(
563     content::BrowserContext* browser_context,
564     const GURL& url,
565     bool private_api,
566     const content::SocketPermissionRequest* params) {
567   NOTREACHED() << "Android WebView does not support plugins";
568   return false;
569 }
570 
IsPepperVpnProviderAPIAllowed(content::BrowserContext * browser_context,const GURL & url)571 bool AwContentBrowserClient::IsPepperVpnProviderAPIAllowed(
572     content::BrowserContext* browser_context,
573     const GURL& url) {
574   NOTREACHED() << "Android WebView does not support plugins";
575   return false;
576 }
577 
GetTracingDelegate()578 content::TracingDelegate* AwContentBrowserClient::GetTracingDelegate() {
579   return new AwTracingDelegate();
580 }
581 
GetAdditionalMappedFilesForChildProcess(const base::CommandLine & command_line,int child_process_id,content::PosixFileDescriptorInfo * mappings)582 void AwContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
583     const base::CommandLine& command_line,
584     int child_process_id,
585     content::PosixFileDescriptorInfo* mappings) {
586   base::MemoryMappedFile::Region region;
587   int fd = ui::GetMainAndroidPackFd(&region);
588   mappings->ShareWithRegion(kAndroidWebViewMainPakDescriptor, fd, region);
589 
590   fd = ui::GetCommonResourcesPackFd(&region);
591   mappings->ShareWithRegion(kAndroidWebView100PercentPakDescriptor, fd, region);
592 
593   fd = ui::GetLocalePackFd(&region);
594   mappings->ShareWithRegion(kAndroidWebViewLocalePakDescriptor, fd, region);
595 
596   int crash_signal_fd =
597       crashpad::CrashHandlerHost::Get()->GetDeathSignalSocket();
598   if (crash_signal_fd >= 0) {
599     mappings->Share(kCrashDumpSignal, crash_signal_fd);
600   }
601 }
602 
OverrideWebkitPrefs(content::RenderViewHost * rvh,blink::web_pref::WebPreferences * web_prefs)603 void AwContentBrowserClient::OverrideWebkitPrefs(
604     content::RenderViewHost* rvh,
605     blink::web_pref::WebPreferences* web_prefs) {
606   AwSettings* aw_settings = AwSettings::FromWebContents(
607       content::WebContents::FromRenderViewHost(rvh));
608   if (aw_settings) {
609     aw_settings->PopulateWebPreferences(web_prefs);
610   }
611 }
612 
613 std::vector<std::unique_ptr<content::NavigationThrottle>>
CreateThrottlesForNavigation(content::NavigationHandle * navigation_handle)614 AwContentBrowserClient::CreateThrottlesForNavigation(
615     content::NavigationHandle* navigation_handle) {
616   std::vector<std::unique_ptr<content::NavigationThrottle>> throttles;
617   // We allow intercepting only navigations within main frames. This
618   // is used to post onPageStarted. We handle shouldOverrideUrlLoading
619   // via a sync IPC.
620   if (navigation_handle->IsInMainFrame()) {
621     // MetricsNavigationThrottle requires that it runs before
622     // NavigationThrottles that may delay or cancel navigations, so only
623     // NavigationThrottles that don't delay or cancel navigations (e.g.
624     // throttles that are only observing callbacks without affecting navigation
625     // behavior) should be added before MetricsNavigationThrottle.
626     throttles.push_back(page_load_metrics::MetricsNavigationThrottle::Create(
627         navigation_handle));
628     // Use Synchronous mode for the navigation interceptor, since this class
629     // doesn't actually call into an arbitrary client, it just posts a task to
630     // call onPageStarted. shouldOverrideUrlLoading happens earlier (see
631     // ContentBrowserClient::ShouldOverrideUrlLoading).
632     throttles.push_back(
633         navigation_interception::InterceptNavigationDelegate::CreateThrottleFor(
634             navigation_handle, navigation_interception::SynchronyMode::kSync));
635     throttles.push_back(std::make_unique<PolicyBlocklistNavigationThrottle>(
636         navigation_handle, AwBrowserContext::FromWebContents(
637                                navigation_handle->GetWebContents())));
638     throttles.push_back(
639         std::make_unique<AwSafeBrowsingNavigationThrottle>(navigation_handle));
640   }
641   return throttles;
642 }
643 
644 content::DevToolsManagerDelegate*
GetDevToolsManagerDelegate()645 AwContentBrowserClient::GetDevToolsManagerDelegate() {
646   return new AwDevToolsManagerDelegate();
647 }
648 
BindAssociatedReceiverFromFrame(content::RenderFrameHost * render_frame_host,const std::string & interface_name,mojo::ScopedInterfaceEndpointHandle * handle)649 bool AwContentBrowserClient::BindAssociatedReceiverFromFrame(
650     content::RenderFrameHost* render_frame_host,
651     const std::string& interface_name,
652     mojo::ScopedInterfaceEndpointHandle* handle) {
653   if (interface_name == autofill::mojom::AutofillDriver::Name_) {
654     autofill::ContentAutofillDriverFactory::BindAutofillDriver(
655         mojo::PendingAssociatedReceiver<autofill::mojom::AutofillDriver>(
656             std::move(*handle)),
657         render_frame_host);
658     return true;
659   }
660   if (interface_name == content_capture::mojom::ContentCaptureReceiver::Name_) {
661     content_capture::ContentCaptureReceiverManager::BindContentCaptureReceiver(
662         mojo::PendingAssociatedReceiver<
663             content_capture::mojom::ContentCaptureReceiver>(std::move(*handle)),
664         render_frame_host);
665     return true;
666   }
667 
668   return false;
669 }
670 
ExposeInterfacesToRenderer(service_manager::BinderRegistry * registry,blink::AssociatedInterfaceRegistry * associated_registry,content::RenderProcessHost * render_process_host)671 void AwContentBrowserClient::ExposeInterfacesToRenderer(
672     service_manager::BinderRegistry* registry,
673     blink::AssociatedInterfaceRegistry* associated_registry,
674     content::RenderProcessHost* render_process_host) {
675   content::ResourceContext* resource_context =
676       render_process_host->GetBrowserContext()->GetResourceContext();
677   registry->AddInterface(
678       base::BindRepeating(
679           &MaybeCreateSafeBrowsing, render_process_host->GetID(),
680           resource_context,
681           base::BindRepeating(
682               &AwContentBrowserClient::GetSafeBrowsingUrlCheckerDelegate,
683               base::Unretained(this))),
684       content::GetUIThreadTaskRunner({}));
685 
686 #if BUILDFLAG(ENABLE_SPELLCHECK)
687   auto create_spellcheck_host =
688       [](mojo::PendingReceiver<spellcheck::mojom::SpellCheckHost> receiver) {
689         mojo::MakeSelfOwnedReceiver(std::make_unique<SpellCheckHostImpl>(),
690                                     std::move(receiver));
691       };
692   registry->AddInterface(base::BindRepeating(create_spellcheck_host),
693                          content::GetUIThreadTaskRunner({}));
694 #endif
695 }
696 
697 std::vector<std::unique_ptr<blink::URLLoaderThrottle>>
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)698 AwContentBrowserClient::CreateURLLoaderThrottles(
699     const network::ResourceRequest& request,
700     content::BrowserContext* browser_context,
701     const base::RepeatingCallback<content::WebContents*()>& wc_getter,
702     content::NavigationUIData* navigation_ui_data,
703     int frame_tree_node_id) {
704   DCHECK_CURRENTLY_ON(BrowserThread::UI);
705 
706   std::vector<std::unique_ptr<blink::URLLoaderThrottle>> result;
707 
708   result.push_back(safe_browsing::BrowserURLLoaderThrottle::Create(
709       base::BindOnce(
710           [](AwContentBrowserClient* client) {
711             return client->GetSafeBrowsingUrlCheckerDelegate();
712           },
713           base::Unretained(this)),
714       wc_getter, frame_tree_node_id,
715       // TODO(crbug.com/1033760): rt_lookup_service is
716       // used to perform real time URL check, which is gated by UKM opted-in.
717       // Since AW currently doesn't support UKM, this feature is not enabled.
718       /* rt_lookup_service */ nullptr));
719 
720   if (request.resource_type ==
721       static_cast<int>(blink::mojom::ResourceType::kMainFrame)) {
722     const bool is_load_url =
723         request.transition_type & ui::PAGE_TRANSITION_FROM_API;
724     const bool is_go_back_forward =
725         request.transition_type & ui::PAGE_TRANSITION_FORWARD_BACK;
726     const bool is_reload = ui::PageTransitionCoreTypeIs(
727         static_cast<ui::PageTransition>(request.transition_type),
728         ui::PAGE_TRANSITION_RELOAD);
729     if (is_load_url || is_go_back_forward || is_reload) {
730       result.push_back(
731           std::make_unique<AwURLLoaderThrottle>(static_cast<AwResourceContext*>(
732               browser_context->GetResourceContext())));
733     }
734   }
735 
736   return result;
737 }
738 
739 scoped_refptr<safe_browsing::UrlCheckerDelegate>
GetSafeBrowsingUrlCheckerDelegate()740 AwContentBrowserClient::GetSafeBrowsingUrlCheckerDelegate() {
741   DCHECK_CURRENTLY_ON(BrowserThread::IO);
742 
743   if (!safe_browsing_url_checker_delegate_) {
744     safe_browsing_url_checker_delegate_ = new AwUrlCheckerDelegateImpl(
745         AwBrowserProcess::GetInstance()->GetSafeBrowsingDBManager(),
746         AwBrowserProcess::GetInstance()->GetSafeBrowsingUIManager(),
747         AwBrowserProcess::GetInstance()->GetSafeBrowsingAllowlistManager());
748   }
749 
750   return safe_browsing_url_checker_delegate_;
751 }
752 
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)753 bool AwContentBrowserClient::ShouldOverrideUrlLoading(
754     int frame_tree_node_id,
755     bool browser_initiated,
756     const GURL& gurl,
757     const std::string& request_method,
758     bool has_user_gesture,
759     bool is_redirect,
760     bool is_main_frame,
761     ui::PageTransition transition,
762     bool* ignore_navigation) {
763   *ignore_navigation = false;
764 
765   // Only GETs can be overridden.
766   if (request_method != "GET")
767     return true;
768 
769   bool application_initiated =
770       browser_initiated || transition & ui::PAGE_TRANSITION_FORWARD_BACK;
771 
772   // Don't offer application-initiated navigations unless it's a redirect.
773   if (application_initiated && !is_redirect)
774     return true;
775 
776   // For HTTP schemes, only top-level navigations can be overridden. Similarly,
777   // WebView Classic lets app override only top level about:blank navigations.
778   // So we filter out non-top about:blank navigations here.
779   //
780   // Note: about:blank navigations are not received in this path at the moment,
781   // they use the old SYNC IPC path as they are not handled by network stack.
782   // However, the old path should be removed in future.
783   if (!is_main_frame &&
784       (gurl.SchemeIs(url::kHttpScheme) || gurl.SchemeIs(url::kHttpsScheme) ||
785        gurl.SchemeIs(url::kAboutScheme)))
786     return true;
787 
788   WebContents* web_contents =
789       WebContents::FromFrameTreeNodeId(frame_tree_node_id);
790   if (web_contents == nullptr)
791     return true;
792   AwContentsClientBridge* client_bridge =
793       AwContentsClientBridge::FromWebContents(web_contents);
794   if (client_bridge == nullptr)
795     return true;
796 
797   base::string16 url = base::UTF8ToUTF16(gurl.possibly_invalid_spec());
798   return client_bridge->ShouldOverrideUrlLoading(
799       url, has_user_gesture, is_redirect, is_main_frame, ignore_navigation);
800 }
801 
ShouldCreateThreadPool()802 bool AwContentBrowserClient::ShouldCreateThreadPool() {
803   return g_should_create_thread_pool;
804 }
805 
806 std::unique_ptr<content::LoginDelegate>
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)807 AwContentBrowserClient::CreateLoginDelegate(
808     const net::AuthChallengeInfo& auth_info,
809     content::WebContents* web_contents,
810     const content::GlobalRequestID& request_id,
811     bool is_main_frame,
812     const GURL& url,
813     scoped_refptr<net::HttpResponseHeaders> response_headers,
814     bool first_auth_attempt,
815     LoginAuthRequiredCallback auth_required_callback) {
816   return std::make_unique<AwHttpAuthHandler>(auth_info, web_contents,
817                                              first_auth_attempt,
818                                              std::move(auth_required_callback));
819 }
820 
HandleExternalProtocol(const GURL & url,content::WebContents::OnceGetter web_contents_getter,int child_id,content::NavigationUIData * navigation_data,bool is_main_frame,ui::PageTransition page_transition,bool has_user_gesture,const base::Optional<url::Origin> & initiating_origin,mojo::PendingRemote<network::mojom::URLLoaderFactory> * out_factory)821 bool AwContentBrowserClient::HandleExternalProtocol(
822     const GURL& url,
823     content::WebContents::OnceGetter web_contents_getter,
824     int child_id,
825     content::NavigationUIData* navigation_data,
826     bool is_main_frame,
827     ui::PageTransition page_transition,
828     bool has_user_gesture,
829     const base::Optional<url::Origin>& initiating_origin,
830     mojo::PendingRemote<network::mojom::URLLoaderFactory>* out_factory) {
831   mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver =
832       out_factory->InitWithNewPipeAndPassReceiver();
833   // We don't need to care for |security_options| as the factories constructed
834   // below are used only for navigation.
835   if (content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
836     // Manages its own lifetime.
837     new android_webview::AwProxyingURLLoaderFactory(
838         0 /* process_id */, std::move(receiver), mojo::NullRemote(),
839         true /* intercept_only */, base::nullopt /* security_options */);
840   } else {
841     content::GetIOThreadTaskRunner({})->PostTask(
842         FROM_HERE,
843         base::BindOnce(
844             [](mojo::PendingReceiver<network::mojom::URLLoaderFactory>
845                    receiver) {
846               // Manages its own lifetime.
847               new android_webview::AwProxyingURLLoaderFactory(
848                   0 /* process_id */, std::move(receiver), mojo::NullRemote(),
849                   true /* intercept_only */,
850                   base::nullopt /* security_options */);
851             },
852             std::move(receiver)));
853   }
854   return false;
855 }
856 
RegisterNonNetworkSubresourceURLLoaderFactories(int render_process_id,int render_frame_id,NonNetworkURLLoaderFactoryMap * factories)857 void AwContentBrowserClient::RegisterNonNetworkSubresourceURLLoaderFactories(
858     int render_process_id,
859     int render_frame_id,
860     NonNetworkURLLoaderFactoryMap* factories) {
861   WebContents* web_contents = content::WebContents::FromRenderFrameHost(
862       content::RenderFrameHost::FromID(render_process_id, render_frame_id));
863   AwSettings* aw_settings = AwSettings::FromWebContents(web_contents);
864 
865   if (aw_settings && aw_settings->GetAllowFileAccess()) {
866     AwBrowserContext* aw_browser_context =
867         AwBrowserContext::FromWebContents(web_contents);
868     factories->emplace(
869         url::kFileScheme,
870         content::CreateFileURLLoaderFactory(
871             aw_browser_context->GetPath(),
872             aw_browser_context->GetSharedCorsOriginAccessList()));
873   }
874 }
875 
ShouldIsolateErrorPage(bool in_main_frame)876 bool AwContentBrowserClient::ShouldIsolateErrorPage(bool in_main_frame) {
877   return false;
878 }
879 
ShouldEnableStrictSiteIsolation()880 bool AwContentBrowserClient::ShouldEnableStrictSiteIsolation() {
881   // TODO(lukasza): When/if we eventually add OOPIF support for AW we should
882   // consider running AW tests with and without site-per-process (and this might
883   // require returning true below).  Adding OOPIF support for AW is tracked by
884   // https://crbug.com/806404.
885   return false;
886 }
887 
ShouldDisableSiteIsolation()888 bool AwContentBrowserClient::ShouldDisableSiteIsolation() {
889   // Since AW does not yet support OOPIFs, we must return true here to disable
890   // features that may trigger OOPIFs, such as origin isolation.
891   //
892   // Adding OOPIF support for AW is tracked by https://crbug.com/806404.
893   return true;
894 }
895 
ShouldLockProcessToSite(content::BrowserContext * browser_context,const GURL & effective_url)896 bool AwContentBrowserClient::ShouldLockProcessToSite(
897     content::BrowserContext* browser_context,
898     const GURL& effective_url) {
899   // TODO(lukasza): https://crbug.com/806404: Once Android WebView supports
900   // OOPIFs, we should remove this ShouldLockProcess overload.  Till then,
901   // returning false helps avoid accidentally applying citadel-style Site
902   // Isolation enforcement to Android WebView (and causing incorrect renderer
903   // kills).
904   return false;
905 }
906 
WillCreateURLLoaderFactory(content::BrowserContext * browser_context,content::RenderFrameHost * frame,int render_process_id,URLLoaderFactoryType type,const url::Origin & request_initiator,base::Optional<int64_t> navigation_id,ukm::SourceIdObj ukm_source_id,mojo::PendingReceiver<network::mojom::URLLoaderFactory> * factory_receiver,mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient> * header_client,bool * bypass_redirect_checks,bool * disable_secure_dns,network::mojom::URLLoaderFactoryOverridePtr * factory_override)907 bool AwContentBrowserClient::WillCreateURLLoaderFactory(
908     content::BrowserContext* browser_context,
909     content::RenderFrameHost* frame,
910     int render_process_id,
911     URLLoaderFactoryType type,
912     const url::Origin& request_initiator,
913     base::Optional<int64_t> navigation_id,
914     ukm::SourceIdObj ukm_source_id,
915     mojo::PendingReceiver<network::mojom::URLLoaderFactory>* factory_receiver,
916     mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient>*
917         header_client,
918     bool* bypass_redirect_checks,
919     bool* disable_secure_dns,
920     network::mojom::URLLoaderFactoryOverridePtr* factory_override) {
921   DCHECK_CURRENTLY_ON(BrowserThread::UI);
922 
923   mojo::PendingReceiver<network::mojom::URLLoaderFactory> proxied_receiver;
924   mojo::PendingRemote<network::mojom::URLLoaderFactory> target_factory_remote;
925 
926   if (factory_override) {
927     // We are interested in factories "inside" of CORS, so use
928     // |factory_override|.
929     *factory_override = network::mojom::URLLoaderFactoryOverride::New();
930     proxied_receiver =
931         (*factory_override)
932             ->overriding_factory.InitWithNewPipeAndPassReceiver();
933     (*factory_override)->overridden_factory_receiver =
934         target_factory_remote.InitWithNewPipeAndPassReceiver();
935     (*factory_override)->skip_cors_enabled_scheme_check = true;
936   } else {
937     // In this case, |factory_override| is not given. But all callers of
938     // ContentBrowserClient::WillCreateURLLoaderFactory guarantee that
939     // |factory_override| is null only when the security features on the network
940     // service is no-op for requests coming to the URLLoaderFactory. Hence we
941     // can use |factory_receiver| here.
942     proxied_receiver = std::move(*factory_receiver);
943     *factory_receiver = target_factory_remote.InitWithNewPipeAndPassReceiver();
944   }
945   int process_id =
946       type == URLLoaderFactoryType::kNavigation ? 0 : render_process_id;
947 
948   // Android WebView has one non off-the-record browser context.
949   if (frame) {
950     auto security_options =
951         base::make_optional<AwProxyingURLLoaderFactory::SecurityOptions>();
952     security_options->disable_web_security =
953         base::CommandLine::ForCurrentProcess()->HasSwitch(
954             switches::kDisableWebSecurity);
955     const auto& preferences =
956         WebContents::FromRenderFrameHost(frame)->GetOrCreateWebPreferences();
957     // See also //android_webview/docs/cors-and-webview-api.md to understand how
958     // each settings affect CORS behaviors on file:// and content://.
959     if (request_initiator.scheme() == url::kFileScheme) {
960       security_options->disable_web_security |=
961           preferences.allow_universal_access_from_file_urls;
962       // Usual file:// to file:// requests are mapped to kNoCors if the setting
963       // is set to true. Howover, file:///android_{asset|res}/ still uses kCors
964       // and needs to permit it in the |security_options|.
965       security_options->allow_cors_to_same_scheme =
966           preferences.allow_file_access_from_file_urls;
967     } else if (request_initiator.scheme() == url::kContentScheme) {
968       security_options->allow_cors_to_same_scheme =
969           preferences.allow_file_access_from_file_urls ||
970           preferences.allow_universal_access_from_file_urls;
971     }
972     content::GetIOThreadTaskRunner({})->PostTask(
973         FROM_HERE,
974         base::BindOnce(&AwProxyingURLLoaderFactory::CreateProxy, process_id,
975                        std::move(proxied_receiver),
976                        std::move(target_factory_remote), security_options));
977   } else {
978     // A service worker and worker subresources set nullptr to |frame|, and
979     // work without seeing the AllowUniversalAccessFromFileURLs setting. So,
980     // we don't pass a valid |security_options| here.
981     content::GetIOThreadTaskRunner({})->PostTask(
982         FROM_HERE, base::BindOnce(&AwProxyingURLLoaderFactory::CreateProxy,
983                                   process_id, std::move(proxied_receiver),
984                                   std::move(target_factory_remote),
985                                   base::nullopt /* security_options */));
986   }
987   return true;
988 }
989 
GetWebSocketOptions(content::RenderFrameHost * frame)990 uint32_t AwContentBrowserClient::GetWebSocketOptions(
991     content::RenderFrameHost* frame) {
992   uint32_t options = network::mojom::kWebSocketOptionNone;
993   if (!frame) {
994     return options;
995   }
996   content::WebContents* web_contents =
997       content::WebContents::FromRenderFrameHost(frame);
998   AwContents* aw_contents = AwContents::FromWebContents(web_contents);
999 
1000   bool global_cookie_policy =
1001       AwCookieAccessPolicy::GetInstance()->GetShouldAcceptCookies();
1002   bool third_party_cookie_policy = aw_contents->AllowThirdPartyCookies();
1003   if (!global_cookie_policy) {
1004     options |= network::mojom::kWebSocketOptionBlockAllCookies;
1005   } else if (!third_party_cookie_policy) {
1006     options |= network::mojom::kWebSocketOptionBlockThirdPartyCookies;
1007   }
1008   return options;
1009 }
1010 
WillCreateRestrictedCookieManager(network::mojom::RestrictedCookieManagerRole role,content::BrowserContext * browser_context,const url::Origin & origin,const net::SiteForCookies & site_for_cookies,const url::Origin & top_frame_origin,bool is_service_worker,int process_id,int routing_id,mojo::PendingReceiver<network::mojom::RestrictedCookieManager> * receiver)1011 bool AwContentBrowserClient::WillCreateRestrictedCookieManager(
1012     network::mojom::RestrictedCookieManagerRole role,
1013     content::BrowserContext* browser_context,
1014     const url::Origin& origin,
1015     const net::SiteForCookies& site_for_cookies,
1016     const url::Origin& top_frame_origin,
1017     bool is_service_worker,
1018     int process_id,
1019     int routing_id,
1020     mojo::PendingReceiver<network::mojom::RestrictedCookieManager>* receiver) {
1021   mojo::PendingReceiver<network::mojom::RestrictedCookieManager> orig_receiver =
1022       std::move(*receiver);
1023 
1024   mojo::PendingRemote<network::mojom::RestrictedCookieManager>
1025       target_rcm_remote;
1026   *receiver = target_rcm_remote.InitWithNewPipeAndPassReceiver();
1027 
1028   AwProxyingRestrictedCookieManager::CreateAndBind(
1029       std::move(target_rcm_remote), is_service_worker, process_id, routing_id,
1030       std::move(orig_receiver));
1031 
1032   return false;  // only made a proxy, still need the actual impl to be made.
1033 }
1034 
GetProduct()1035 std::string AwContentBrowserClient::GetProduct() {
1036   return android_webview::GetProduct();
1037 }
1038 
GetUserAgent()1039 std::string AwContentBrowserClient::GetUserAgent() {
1040   return android_webview::GetUserAgent();
1041 }
1042 
1043 content::ContentBrowserClient::WideColorGamutHeuristic
GetWideColorGamutHeuristic()1044 AwContentBrowserClient::GetWideColorGamutHeuristic() {
1045   if (base::FeatureList::IsEnabled(features::kWebViewWideColorGamutSupport))
1046     return WideColorGamutHeuristic::kUseWindow;
1047 
1048   if (display::Display::HasForceDisplayColorProfile() &&
1049       display::Display::GetForcedDisplayColorProfile() ==
1050           gfx::ColorSpace::CreateDisplayP3D65()) {
1051     return WideColorGamutHeuristic::kUseWindow;
1052   }
1053 
1054   return WideColorGamutHeuristic::kNone;
1055 }
1056 
LogWebFeatureForCurrentPage(content::RenderFrameHost * render_frame_host,blink::mojom::WebFeature feature)1057 void AwContentBrowserClient::LogWebFeatureForCurrentPage(
1058     content::RenderFrameHost* render_frame_host,
1059     blink::mojom::WebFeature feature) {
1060   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1061   page_load_metrics::mojom::PageLoadFeatures new_features({feature}, {}, {});
1062   page_load_metrics::MetricsWebContentsObserver::RecordFeatureUsage(
1063       render_frame_host, new_features);
1064 }
1065 
IsOriginTrialRequiredForAppCache(content::BrowserContext * browser_text)1066 bool AwContentBrowserClient::IsOriginTrialRequiredForAppCache(
1067     content::BrowserContext* browser_text) {
1068   // WebView has no way of specifying an origin trial, and so never
1069   // consider it a requirement.
1070   return false;
1071 }
1072 
1073 content::SpeechRecognitionManagerDelegate*
CreateSpeechRecognitionManagerDelegate()1074 AwContentBrowserClient::CreateSpeechRecognitionManagerDelegate() {
1075   return new AwSpeechRecognitionManagerDelegate();
1076 }
1077 
HasErrorPage(int http_status_code)1078 bool AwContentBrowserClient::HasErrorPage(int http_status_code) {
1079   return http_status_code >= 400;
1080 }
1081 
1082 // static
DisableCreatingThreadPool()1083 void AwContentBrowserClient::DisableCreatingThreadPool() {
1084   g_should_create_thread_pool = false;
1085 }
1086 
1087 }  // namespace android_webview
1088