chromecast/browser/cast_content_browser_client.h

   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 #ifndef CHROMECAST_BROWSER_CAST_CONTENT_BROWSER_CLIENT_H_
   6 #define CHROMECAST_BROWSER_CAST_CONTENT_BROWSER_CLIENT_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/macros.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "content/public/browser/content_browser_client.h"
  15
  16 namespace breakpad {
  17 class CrashHandlerHostLinux;
  18 }
  19
  20 namespace content {
  21 class BrowserMessageFilter;
  22 }
  23
  24 namespace media {
  25 class AudioManagerFactory;
  26 }
  27
  28 namespace net {
  29 class HostResolver;
  30 }
  31
  32 namespace chromecast {
  33 namespace media {
  34 class MediaPipelineBackend;
  35 struct MediaPipelineDeviceParams;
  36 }
  37
  38 namespace shell {
  39
  40 class CastBrowserMainParts;
  41 class URLRequestContextFactory;
  42
  43 class CastContentBrowserClient: public content::ContentBrowserClient {
  44  public:
  45   // Creates an implementation of CastContentBrowserClient. Platform should
  46   // link in an implementation as needed.
  47   static scoped_ptr<CastContentBrowserClient> Create();
  48
  49   ~CastContentBrowserClient() override;
  50
  51   // Appends extra command line arguments before launching a new process.
  52   virtual void AppendExtraCommandLineSwitches(base::CommandLine* command_line);
  53
  54   // Returns any BrowserMessageFilters that should be added when launching a
  55   // new render process.
  56   virtual std::vector<scoped_refptr<content::BrowserMessageFilter>>
  57   GetBrowserMessageFilters();
  58
  59   // Provide an AudioManagerFactory instance for WebAudio playback.
  60   virtual scoped_ptr<::media::AudioManagerFactory> CreateAudioManagerFactory();
  61
  62 #if !defined(OS_ANDROID)
  63   // Creates a MediaPipelineDevice (CMA backend) for media playback, called
  64   // once per media player instance.
  65   virtual scoped_ptr<media::MediaPipelineBackend> CreateMediaPipelineBackend(
  66       const media::MediaPipelineDeviceParams& params);
  67 #endif
  68
  69   // content::ContentBrowserClient implementation:
  70   content::BrowserMainParts* CreateBrowserMainParts(
  71       const content::MainFunctionParams& parameters) override;
  72   void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
  73   net::URLRequestContextGetter* CreateRequestContext(
  74       content::BrowserContext* browser_context,
  75       content::ProtocolHandlerMap* protocol_handlers,
  76       content::URLRequestInterceptorScopedVector request_interceptors)
  77       override;
  78   bool IsHandledURL(const GURL& url) override;
  79   void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
  80                                       int child_process_id) override;
  81   content::AccessTokenStore* CreateAccessTokenStore() override;
  82   void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
  83                            content::WebPreferences* prefs) override;
  84   void ResourceDispatcherHostCreated() override;
  85   std::string GetApplicationLocale() override;
  86   content::QuotaPermissionContext* CreateQuotaPermissionContext() override;
  87   void AllowCertificateError(
  88       int render_process_id,
  89       int render_view_id,
  90       int cert_error,
  91       const net::SSLInfo& ssl_info,
  92       const GURL& request_url,
  93       content::ResourceType resource_type,
  94       bool overridable,
  95       bool strict_enforcement,
  96       bool expired_previous_decision,
  97       const base::Callback<void(bool)>& callback,
  98       content::CertificateRequestResultType* result) override;
  99   void SelectClientCertificate(
 100       content::WebContents* web_contents,
 101       net::SSLCertRequestInfo* cert_request_info,
 102       scoped_ptr<content::ClientCertificateDelegate> delegate) override;
 103   bool CanCreateWindow(
 104       const GURL& opener_url,
 105       const GURL& opener_top_level_frame_url,
 106       const GURL& source_origin,
 107       WindowContainerType container_type,
 108       const GURL& target_url,
 109       const content::Referrer& referrer,
 110       WindowOpenDisposition disposition,
 111       const blink::WebWindowFeatures& features,
 112       bool user_gesture,
 113       bool opener_suppressed,
 114       content::ResourceContext* context,
 115       int render_process_id,
 116       int opener_render_view_id,
 117       int opener_render_frame_id,
 118       bool* no_javascript_access) override;
 119   void RegisterUnsandboxedOutOfProcessMojoApplications(
 120       std::vector<GURL>* urls) override;
 121 #if defined(OS_ANDROID)
 122   void GetAdditionalMappedFilesForChildProcess(
 123       const base::CommandLine& command_line,
 124       int child_process_id,
 125       content::FileDescriptorInfo* mappings,
 126       std::map<int, base::MemoryMappedFile::Region>* regions) override;
 127 #else
 128   void GetAdditionalMappedFilesForChildProcess(
 129       const base::CommandLine& command_line,
 130       int child_process_id,
 131       content::FileDescriptorInfo* mappings) override;
 132 #endif  // defined(OS_ANDROID)
 133 #if defined(OS_ANDROID) && defined(VIDEO_HOLE)
 134   content::ExternalVideoSurfaceContainer*
 135   OverrideCreateExternalVideoSurfaceContainer(
 136       content::WebContents* web_contents) override;
 137 #endif  // defined(OS_ANDROID) && defined(VIDEO_HOLE)
 138
 139  protected:
 140   CastContentBrowserClient();
 141
 142  private:
 143   void AddNetworkHintsMessageFilter(int render_process_id,
 144                                     net::URLRequestContext* context);
 145
 146   net::X509Certificate* SelectClientCertificateOnIOThread(
 147       GURL requesting_url,
 148       int render_process_id);
 149
 150 #if !defined(OS_ANDROID)
 151   // Returns the crash signal FD corresponding to the current process type.
 152   int GetCrashSignalFD(const base::CommandLine& command_line);
 153
 154   // Creates a CrashHandlerHost instance for the given process type.
 155   breakpad::CrashHandlerHostLinux* CreateCrashHandlerHost(
 156       const std::string& process_type);
 157
 158   // A static cache to hold crash_handlers for each process_type
 159   std::map<std::string, breakpad::CrashHandlerHostLinux*> crash_handlers_;
 160 #endif
 161
 162   scoped_ptr<URLRequestContextFactory> url_request_context_factory_;
 163
 164   DISALLOW_COPY_AND_ASSIGN(CastContentBrowserClient);
 165 };
 166
 167 }  // namespace shell
 168 }  // namespace chromecast
 169
 170 #endif  // CHROMECAST_BROWSER_CAST_CONTENT_BROWSER_CLIENT_H_