android_webview/browser/aw_content_browser_client.cc

   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 "android_webview/browser/aw_browser_context.h"
   8 #include "android_webview/browser/aw_browser_main_parts.h"
   9 #include "android_webview/browser/aw_contents_client_bridge_base.h"
  10 #include "android_webview/browser/aw_contents_io_thread_client.h"
  11 #include "android_webview/browser/aw_cookie_access_policy.h"
  12 #include "android_webview/browser/aw_printing_message_filter.h"
  13 #include "android_webview/browser/aw_quota_permission_context.h"
  14 #include "android_webview/browser/aw_web_preferences_populater.h"
  15 #include "android_webview/browser/jni_dependency_factory.h"
  16 #include "android_webview/browser/net/aw_url_request_context_getter.h"
  17 #include "android_webview/browser/net_disk_cache_remover.h"
  18 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
  19 #include "android_webview/common/render_view_messages.h"
  20 #include "android_webview/common/url_constants.h"
  21 #include "base/android/locale_utils.h"
  22 #include "base/base_paths_android.h"
  23 #include "base/path_service.h"
  24 #include "components/cdm/browser/cdm_message_filter_android.h"
  25 #include "content/public/browser/access_token_store.h"
  26 #include "content/public/browser/browser_message_filter.h"
  27 #include "content/public/browser/browser_thread.h"
  28 #include "content/public/browser/child_process_security_policy.h"
  29 #include "content/public/browser/client_certificate_delegate.h"
  30 #include "content/public/browser/render_frame_host.h"
  31 #include "content/public/browser/render_process_host.h"
  32 #include "content/public/browser/render_view_host.h"
  33 #include "content/public/browser/web_contents.h"
  34 #include "content/public/common/url_constants.h"
  35 #include "content/public/common/web_preferences.h"
  36 #include "net/android/network_library.h"
  37 #include "net/ssl/ssl_cert_request_info.h"
  38 #include "net/ssl/ssl_info.h"
  39 #include "ui/base/resource/resource_bundle.h"
  40 #include "ui/resources/grit/ui_resources.h"
  41
  42 using content::BrowserThread;
  43 using content::ResourceType;
  44
  45 namespace android_webview {
  46 namespace {
  47
  48 // TODO(sgurun) move this to its own file.
  49 // This class filters out incoming aw_contents related IPC messages for the
  50 // renderer process on the IPC thread.
  51 class AwContentsMessageFilter : public content::BrowserMessageFilter {
  52 public:
  53   explicit AwContentsMessageFilter(int process_id);
  54
  55   // BrowserMessageFilter methods.
  56   void OverrideThreadForMessage(const IPC::Message& message,
  57                                 BrowserThread::ID* thread) override;
  58   bool OnMessageReceived(const IPC::Message& message) override;
  59
  60   void OnShouldOverrideUrlLoading(int routing_id,
  61                                   const base::string16& url,
  62                                   bool* ignore_navigation);
  63   void OnSubFrameCreated(int parent_render_frame_id, int child_render_frame_id);
  64
  65 private:
  66  ~AwContentsMessageFilter() override;
  67
  68   int process_id_;
  69
  70   DISALLOW_COPY_AND_ASSIGN(AwContentsMessageFilter);
  71 };
  72
  73 AwContentsMessageFilter::AwContentsMessageFilter(int process_id)
  74     : BrowserMessageFilter(AndroidWebViewMsgStart),
  75       process_id_(process_id) {
  76 }
  77
  78 AwContentsMessageFilter::~AwContentsMessageFilter() {
  79 }
  80
  81 void AwContentsMessageFilter::OverrideThreadForMessage(
  82     const IPC::Message& message, BrowserThread::ID* thread) {
  83   if (message.type() == AwViewHostMsg_ShouldOverrideUrlLoading::ID) {
  84     *thread = BrowserThread::UI;
  85   }
  86 }
  87
  88 bool AwContentsMessageFilter::OnMessageReceived(const IPC::Message& message) {
  89   bool handled = true;
  90   IPC_BEGIN_MESSAGE_MAP(AwContentsMessageFilter, message)
  91     IPC_MESSAGE_HANDLER(AwViewHostMsg_ShouldOverrideUrlLoading,
  92                         OnShouldOverrideUrlLoading)
  93     IPC_MESSAGE_HANDLER(AwViewHostMsg_SubFrameCreated, OnSubFrameCreated)
  94     IPC_MESSAGE_UNHANDLED(handled = false)
  95   IPC_END_MESSAGE_MAP()
  96   return handled;
  97 }
  98
  99 void AwContentsMessageFilter::OnShouldOverrideUrlLoading(
 100     int render_frame_id,
 101     const base::string16& url,
 102     bool* ignore_navigation) {
 103   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 104   *ignore_navigation = false;
 105   AwContentsClientBridgeBase* client =
 106       AwContentsClientBridgeBase::FromID(process_id_, render_frame_id);
 107   if (client) {
 108     *ignore_navigation = client->ShouldOverrideUrlLoading(url);
 109   } else {
 110     LOG(WARNING) << "Failed to find the associated render view host for url: "
 111                  << url;
 112   }
 113 }
 114
 115 void AwContentsMessageFilter::OnSubFrameCreated(int parent_render_frame_id,
 116                                                 int child_render_frame_id) {
 117   AwContentsIoThreadClient::SubFrameCreated(
 118       process_id_, parent_render_frame_id, child_render_frame_id);
 119 }
 120
 121 class AwAccessTokenStore : public content::AccessTokenStore {
 122  public:
 123   AwAccessTokenStore() { }
 124
 125   // content::AccessTokenStore implementation
 126   void LoadAccessTokens(const LoadAccessTokensCallbackType& request) override {
 127     AccessTokenStore::AccessTokenSet access_token_set;
 128     // AccessTokenSet and net::URLRequestContextGetter not used on Android,
 129     // but Run needs to be called to finish the geolocation setup.
 130     request.Run(access_token_set, NULL);
 131   }
 132   void SaveAccessToken(const GURL& server_url,
 133                        const base::string16& access_token) override {}
 134
 135  private:
 136   ~AwAccessTokenStore() override {}
 137
 138   DISALLOW_COPY_AND_ASSIGN(AwAccessTokenStore);
 139 };
 140
 141 }  // anonymous namespace
 142
 143 std::string AwContentBrowserClient::GetAcceptLangsImpl() {
 144   // Start with the currnet locale.
 145   std::string langs = base::android::GetDefaultLocale();
 146
 147   // If we're not en-US, add in en-US which will be
 148   // used with a lower q-value.
 149   if (base::StringToLowerASCII(langs) != "en-us") {
 150     langs += ",en-US";
 151   }
 152   return langs;
 153 }
 154
 155 AwBrowserContext* AwContentBrowserClient::GetAwBrowserContext() {
 156   return AwBrowserContext::GetDefault();
 157 }
 158
 159 AwContentBrowserClient::AwContentBrowserClient(
 160     JniDependencyFactory* native_factory)
 161     : native_factory_(native_factory) {
 162   base::FilePath user_data_dir;
 163   if (!PathService::Get(base::DIR_ANDROID_APP_DATA, &user_data_dir)) {
 164     NOTREACHED() << "Failed to get app data directory for Android WebView";
 165   }
 166   browser_context_.reset(
 167       new AwBrowserContext(user_data_dir, native_factory_));
 168 }
 169
 170 AwContentBrowserClient::~AwContentBrowserClient() {
 171 }
 172
 173 void AwContentBrowserClient::AddCertificate(net::CertificateMimeType cert_type,
 174                                             const void* cert_data,
 175                                             size_t cert_size,
 176                                             int render_process_id,
 177                                             int render_frame_id) {
 178   if (cert_size > 0)
 179     net::android::StoreCertificate(cert_type, cert_data, cert_size);
 180 }
 181
 182 content::BrowserMainParts* AwContentBrowserClient::CreateBrowserMainParts(
 183     const content::MainFunctionParams& parameters) {
 184   return new AwBrowserMainParts(browser_context_.get());
 185 }
 186
 187 content::WebContentsViewDelegate*
 188 AwContentBrowserClient::GetWebContentsViewDelegate(
 189     content::WebContents* web_contents) {
 190   return native_factory_->CreateViewDelegate(web_contents);
 191 }
 192
 193 void AwContentBrowserClient::RenderProcessWillLaunch(
 194     content::RenderProcessHost* host) {
 195   // If WebView becomes multi-process capable, this may be insecure.
 196   // More benefit can be derived from the ChildProcessSecurotyPolicy by
 197   // deferring the GrantScheme calls until we know that a given child process
 198   // really does need that priviledge. Check here to ensure we rethink this
 199   // when the time comes. See crbug.com/156062.
 200   CHECK(content::RenderProcessHost::run_renderer_in_process());
 201
 202   // Grant content: and file: scheme to the whole process, since we impose
 203   // per-view access checks.
 204   content::ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
 205       host->GetID(), android_webview::kContentScheme);
 206   content::ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
 207       host->GetID(), url::kFileScheme);
 208
 209   host->AddFilter(new AwContentsMessageFilter(host->GetID()));
 210   host->AddFilter(new cdm::CdmMessageFilterAndroid());
 211   host->AddFilter(new AwPrintingMessageFilter(host->GetID()));
 212 }
 213
 214 net::URLRequestContextGetter* AwContentBrowserClient::CreateRequestContext(
 215     content::BrowserContext* browser_context,
 216     content::ProtocolHandlerMap* protocol_handlers,
 217     content::URLRequestInterceptorScopedVector request_interceptors) {
 218   DCHECK_EQ(browser_context_.get(), browser_context);
 219   return browser_context_->CreateRequestContext(protocol_handlers,
 220                                                 request_interceptors.Pass());
 221 }
 222
 223 net::URLRequestContextGetter*
 224 AwContentBrowserClient::CreateRequestContextForStoragePartition(
 225     content::BrowserContext* browser_context,
 226     const base::FilePath& partition_path,
 227     bool in_memory,
 228     content::ProtocolHandlerMap* protocol_handlers,
 229     content::URLRequestInterceptorScopedVector request_interceptors) {
 230   DCHECK_EQ(browser_context_.get(), browser_context);
 231   // TODO(mkosiba,kinuko): request_interceptors should be hooked up in the
 232   // downstream. (crbug.com/350286)
 233   return browser_context_->CreateRequestContextForStoragePartition(
 234       partition_path, in_memory, protocol_handlers,
 235       request_interceptors.Pass());
 236 }
 237
 238 std::string AwContentBrowserClient::GetCanonicalEncodingNameByAliasName(
 239     const std::string& alias_name) {
 240   return alias_name;
 241 }
 242
 243 void AwContentBrowserClient::AppendExtraCommandLineSwitches(
 244     base::CommandLine* command_line,
 245     int child_process_id) {
 246   NOTREACHED() << "Android WebView does not support multi-process yet";
 247 }
 248
 249 std::string AwContentBrowserClient::GetApplicationLocale() {
 250   return base::android::GetDefaultLocale();
 251 }
 252
 253 std::string AwContentBrowserClient::GetAcceptLangs(
 254     content::BrowserContext* context) {
 255   return GetAcceptLangsImpl();
 256 }
 257
 258 const gfx::ImageSkia* AwContentBrowserClient::GetDefaultFavicon() {
 259   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 260   // TODO(boliu): Bundle our own default favicon?
 261   return rb.GetImageSkiaNamed(IDR_DEFAULT_FAVICON);
 262 }
 263
 264 bool AwContentBrowserClient::AllowAppCache(const GURL& manifest_url,
 265                            const GURL& first_party,
 266                            content::ResourceContext* context) {
 267   // WebView doesn't have a per-site policy for locally stored data,
 268   // instead AppCache can be disabled for individual WebViews.
 269   return true;
 270 }
 271
 272
 273 bool AwContentBrowserClient::AllowGetCookie(const GURL& url,
 274                                             const GURL& first_party,
 275                                             const net::CookieList& cookie_list,
 276                                             content::ResourceContext* context,
 277                                             int render_process_id,
 278                                             int render_frame_id) {
 279   return AwCookieAccessPolicy::GetInstance()->AllowGetCookie(url,
 280                                                              first_party,
 281                                                              cookie_list,
 282                                                              context,
 283                                                              render_process_id,
 284                                                              render_frame_id);
 285 }
 286
 287 bool AwContentBrowserClient::AllowSetCookie(const GURL& url,
 288                                             const GURL& first_party,
 289                                             const std::string& cookie_line,
 290                                             content::ResourceContext* context,
 291                                             int render_process_id,
 292                                             int render_frame_id,
 293                                             net::CookieOptions* options) {
 294   return AwCookieAccessPolicy::GetInstance()->AllowSetCookie(url,
 295                                                              first_party,
 296                                                              cookie_line,
 297                                                              context,
 298                                                              render_process_id,
 299                                                              render_frame_id,
 300                                                              options);
 301 }
 302
 303 bool AwContentBrowserClient::AllowWorkerDatabase(
 304     const GURL& url,
 305     const base::string16& name,
 306     const base::string16& display_name,
 307     unsigned long estimated_size,
 308     content::ResourceContext* context,
 309     const std::vector<std::pair<int, int> >& render_frames) {
 310   // Android WebView does not yet support web workers.
 311   return false;
 312 }
 313
 314 void AwContentBrowserClient::AllowWorkerFileSystem(
 315     const GURL& url,
 316     content::ResourceContext* context,
 317     const std::vector<std::pair<int, int> >& render_frames,
 318     base::Callback<void(bool)> callback) {
 319   // Android WebView does not yet support web workers.
 320   callback.Run(false);
 321 }
 322
 323 bool AwContentBrowserClient::AllowWorkerIndexedDB(
 324     const GURL& url,
 325     const base::string16& name,
 326     content::ResourceContext* context,
 327     const std::vector<std::pair<int, int> >& render_frames) {
 328   // Android WebView does not yet support web workers.
 329   return false;
 330 }
 331
 332 content::QuotaPermissionContext*
 333 AwContentBrowserClient::CreateQuotaPermissionContext() {
 334   return new AwQuotaPermissionContext;
 335 }
 336
 337 void AwContentBrowserClient::AllowCertificateError(
 338     int render_process_id,
 339     int render_frame_id,
 340     int cert_error,
 341     const net::SSLInfo& ssl_info,
 342     const GURL& request_url,
 343     ResourceType resource_type,
 344     bool overridable,
 345     bool strict_enforcement,
 346     bool expired_previous_decision,
 347     const base::Callback<void(bool)>& callback,
 348     content::CertificateRequestResultType* result) {
 349   AwContentsClientBridgeBase* client =
 350       AwContentsClientBridgeBase::FromID(render_process_id, render_frame_id);
 351   bool cancel_request = true;
 352   if (client)
 353     client->AllowCertificateError(cert_error,
 354                                   ssl_info.cert.get(),
 355                                   request_url,
 356                                   callback,
 357                                   &cancel_request);
 358   if (cancel_request)
 359     *result = content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY;
 360 }
 361
 362 void AwContentBrowserClient::SelectClientCertificate(
 363     content::WebContents* web_contents,
 364     net::SSLCertRequestInfo* cert_request_info,
 365     scoped_ptr<content::ClientCertificateDelegate> delegate) {
 366   AwContentsClientBridgeBase* client =
 367       AwContentsClientBridgeBase::FromWebContents(web_contents);
 368   if (client)
 369     client->SelectClientCertificate(cert_request_info, delegate.Pass());
 370 }
 371
 372 bool AwContentBrowserClient::CanCreateWindow(
 373     const GURL& opener_url,
 374     const GURL& opener_top_level_frame_url,
 375     const GURL& source_origin,
 376     WindowContainerType container_type,
 377     const GURL& target_url,
 378     const content::Referrer& referrer,
 379     WindowOpenDisposition disposition,
 380     const blink::WebWindowFeatures& features,
 381     bool user_gesture,
 382     bool opener_suppressed,
 383     content::ResourceContext* context,
 384     int render_process_id,
 385     int opener_id,
 386     bool* no_javascript_access) {
 387   // We unconditionally allow popup windows at this stage and will give
 388   // the embedder the opporunity to handle displaying of the popup in
 389   // WebContentsDelegate::AddContents (via the
 390   // AwContentsClient.onCreateWindow callback).
 391   // Note that if the embedder has blocked support for creating popup
 392   // windows through AwSettings, then we won't get to this point as
 393   // the popup creation will have been blocked at the WebKit level.
 394   if (no_javascript_access) {
 395     *no_javascript_access = false;
 396   }
 397   return true;
 398 }
 399
 400 void AwContentBrowserClient::ResourceDispatcherHostCreated() {
 401   AwResourceDispatcherHostDelegate::ResourceDispatcherHostCreated();
 402 }
 403
 404 net::NetLog* AwContentBrowserClient::GetNetLog() {
 405   return browser_context_->GetAwURLRequestContext()->GetNetLog();
 406 }
 407
 408 content::AccessTokenStore* AwContentBrowserClient::CreateAccessTokenStore() {
 409   return new AwAccessTokenStore();
 410 }
 411
 412 bool AwContentBrowserClient::IsFastShutdownPossible() {
 413   NOTREACHED() << "Android WebView is single process, so IsFastShutdownPossible"
 414                << " should never be called";
 415   return false;
 416 }
 417
 418 void AwContentBrowserClient::ClearCache(content::RenderFrameHost* rfh) {
 419   RemoveHttpDiskCache(rfh->GetProcess()->GetBrowserContext(),
 420                       rfh->GetProcess()->GetID());
 421 }
 422
 423 void AwContentBrowserClient::ClearCookies(content::RenderFrameHost* rfh) {
 424   // TODO(boliu): Implement.
 425   NOTIMPLEMENTED();
 426 }
 427
 428 base::FilePath AwContentBrowserClient::GetDefaultDownloadDirectory() {
 429   // Android WebView does not currently use the Chromium downloads system.
 430   // Download requests are cancelled immedately when recognized; see
 431   // AwResourceDispatcherHost::CreateResourceHandlerForDownload. However the
 432   // download system still tries to start up and calls this before recognizing
 433   // the request has been cancelled.
 434   return base::FilePath();
 435 }
 436
 437 std::string AwContentBrowserClient::GetDefaultDownloadName() {
 438   NOTREACHED() << "Android WebView does not use chromium downloads";
 439   return std::string();
 440 }
 441
 442 void AwContentBrowserClient::DidCreatePpapiPlugin(
 443     content::BrowserPpapiHost* browser_host) {
 444   NOTREACHED() << "Android WebView does not support plugins";
 445 }
 446
 447 bool AwContentBrowserClient::AllowPepperSocketAPI(
 448     content::BrowserContext* browser_context,
 449     const GURL& url,
 450     bool private_api,
 451     const content::SocketPermissionRequest* params) {
 452   NOTREACHED() << "Android WebView does not support plugins";
 453   return false;
 454 }
 455
 456 void AwContentBrowserClient::OverrideWebkitPrefs(
 457     content::RenderViewHost* rvh,
 458     content::WebPreferences* web_prefs) {
 459   if (!preferences_populater_.get()) {
 460     preferences_populater_ = make_scoped_ptr(native_factory_->
 461         CreateWebPreferencesPopulater());
 462   }
 463   preferences_populater_->PopulateFor(
 464       content::WebContents::FromRenderViewHost(rvh), web_prefs);
 465 }
 466
 467 #if defined(VIDEO_HOLE)
 468 content::ExternalVideoSurfaceContainer*
 469 AwContentBrowserClient::OverrideCreateExternalVideoSurfaceContainer(
 470     content::WebContents* web_contents) {
 471   return native_factory_->CreateExternalVideoSurfaceContainer(web_contents);
 472 }
 473 #endif
 474
 475 }  // namespace android_webview