chromecast/shell/browser/cast_content_browser_client.cc

   1 // Copyright 2014 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 "chromecast/shell/browser/cast_content_browser_client.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/i18n/rtl.h"
   9 #include "base/path_service.h"
  10 #include "chromecast/common/cast_paths.h"
  11 #include "chromecast/common/global_descriptors.h"
  12 #include "chromecast/shell/browser/cast_browser_context.h"
  13 #include "chromecast/shell/browser/cast_browser_main_parts.h"
  14 #include "chromecast/shell/browser/cast_browser_process.h"
  15 #include "chromecast/shell/browser/devtools/cast_dev_tools_delegate.h"
  16 #include "chromecast/shell/browser/geolocation/cast_access_token_store.h"
  17 #include "chromecast/shell/browser/url_request_context_factory.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/browser/certificate_request_result_type.h"
  20 #include "content/public/browser/file_descriptor_info.h"
  21 #include "content/public/browser/render_process_host.h"
  22 #include "content/public/common/content_descriptors.h"
  23 #include "content/public/common/content_switches.h"
  24 #include "content/public/common/url_constants.h"
  25 #include "content/public/common/web_preferences.h"
  26
  27 namespace chromecast {
  28 namespace shell {
  29
  30 CastContentBrowserClient::CastContentBrowserClient()
  31     : url_request_context_factory_(new URLRequestContextFactory()) {
  32 }
  33
  34 CastContentBrowserClient::~CastContentBrowserClient() {
  35   content::BrowserThread::DeleteSoon(
  36       content::BrowserThread::IO,
  37       FROM_HERE,
  38       url_request_context_factory_.release());
  39 }
  40
  41 content::BrowserMainParts* CastContentBrowserClient::CreateBrowserMainParts(
  42     const content::MainFunctionParams& parameters) {
  43   return new CastBrowserMainParts(parameters,
  44                                   url_request_context_factory_.get());
  45 }
  46
  47 void CastContentBrowserClient::RenderProcessWillLaunch(
  48     content::RenderProcessHost* host) {
  49 }
  50
  51 net::URLRequestContextGetter* CastContentBrowserClient::CreateRequestContext(
  52     content::BrowserContext* browser_context,
  53     content::ProtocolHandlerMap* protocol_handlers,
  54     content::URLRequestInterceptorScopedVector request_interceptors) {
  55   return url_request_context_factory_->CreateMainGetter(
  56       browser_context,
  57       protocol_handlers,
  58       request_interceptors.Pass());
  59 }
  60
  61 bool CastContentBrowserClient::IsHandledURL(const GURL& url) {
  62   if (!url.is_valid())
  63     return false;
  64
  65   static const char* const kProtocolList[] = {
  66       url::kBlobScheme,
  67       url::kFileSystemScheme,
  68       content::kChromeUIScheme,
  69       content::kChromeDevToolsScheme,
  70       url::kDataScheme,
  71 #if defined(OS_ANDROID)
  72       url::kFileScheme,
  73 #endif  // defined(OS_ANDROID)
  74   };
  75
  76   const std::string& scheme = url.scheme();
  77   for (size_t i = 0; i < arraysize(kProtocolList); ++i) {
  78     if (scheme == kProtocolList[i])
  79       return true;
  80   }
  81   return false;
  82 }
  83
  84 void CastContentBrowserClient::AppendExtraCommandLineSwitches(
  85     base::CommandLine* command_line,
  86     int child_process_id) {
  87
  88   std::string process_type =
  89       command_line->GetSwitchValueNative(switches::kProcessType);
  90   // Renderer process comamndline
  91   if (process_type == switches::kRendererProcess) {
  92     // Any browser command-line switches that should be propagated to
  93     // the renderer go here.
  94   }
  95 }
  96
  97 content::AccessTokenStore* CastContentBrowserClient::CreateAccessTokenStore() {
  98   return new CastAccessTokenStore(
  99       CastBrowserProcess::GetInstance()->browser_context());
 100 }
 101
 102 void CastContentBrowserClient::OverrideWebkitPrefs(
 103     content::RenderViewHost* render_view_host,
 104     const GURL& url,
 105     content::WebPreferences* prefs) {
 106   prefs->allow_scripts_to_close_windows = true;
 107   // TODO(lcwu): http://crbug.com/391089. This pref is set to true by default
 108   // because some content providers such as YouTube use plain http requests
 109   // to retrieve media data chunks while running in a https page. This pref
 110   // should be disabled once all the content providers are no longer doing that.
 111   prefs->allow_running_insecure_content = true;
 112 }
 113
 114 std::string CastContentBrowserClient::GetApplicationLocale() {
 115   const std::string locale(base::i18n::GetConfiguredLocale());
 116   return locale.empty() ? "en-US" : locale;
 117 }
 118
 119 void CastContentBrowserClient::AllowCertificateError(
 120     int render_process_id,
 121     int render_view_id,
 122     int cert_error,
 123     const net::SSLInfo& ssl_info,
 124     const GURL& request_url,
 125     content::ResourceType resource_type,
 126     bool overridable,
 127     bool strict_enforcement,
 128     bool expired_previous_decision,
 129     const base::Callback<void(bool)>& callback,
 130     content::CertificateRequestResultType* result) {
 131   // Allow developers to override certificate errors.
 132   // Otherwise, any fatal certificate errors will cause an abort.
 133   *result = content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
 134   return;
 135 }
 136
 137 bool CastContentBrowserClient::CanCreateWindow(
 138     const GURL& opener_url,
 139     const GURL& opener_top_level_frame_url,
 140     const GURL& source_origin,
 141     WindowContainerType container_type,
 142     const GURL& target_url,
 143     const content::Referrer& referrer,
 144     WindowOpenDisposition disposition,
 145     const blink::WebWindowFeatures& features,
 146     bool user_gesture,
 147     bool opener_suppressed,
 148     content::ResourceContext* context,
 149     int render_process_id,
 150     int opener_id,
 151     bool* no_javascript_access) {
 152   *no_javascript_access = true;
 153   return false;
 154 }
 155
 156 content::DevToolsManagerDelegate*
 157 CastContentBrowserClient::GetDevToolsManagerDelegate() {
 158   return new CastDevToolsManagerDelegate();
 159 }
 160
 161 void CastContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
 162     const base::CommandLine& command_line,
 163     int child_process_id,
 164     std::vector<content::FileDescriptorInfo>* mappings) {
 165 #if defined(OS_ANDROID)
 166   int flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
 167   base::FilePath pak_file;
 168   CHECK(PathService::Get(FILE_CAST_PAK, &pak_file));
 169   base::File pak_with_flags(pak_file, flags);
 170   if (!pak_with_flags.IsValid()) {
 171     NOTREACHED() << "Failed to open file when creating renderer process: "
 172                  << "cast_shell.pak";
 173   }
 174   mappings->push_back(content::FileDescriptorInfo(
 175       kAndroidPakDescriptor,
 176       base::FileDescriptor(base::File(pak_file, flags))));
 177 #endif  // defined(OS_ANDROID)
 178 }
 179
 180 }  // namespace shell
 181 }  // namespace chromecast