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 MediaPipelineDevice;
  35 class 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::MediaPipelineDevice> CreateMediaPipelineDevice(
  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 #if defined(OS_ANDROID)
 120   void GetAdditionalMappedFilesForChildProcess(
 121       const base::CommandLine& command_line,
 122       int child_process_id,
 123       content::FileDescriptorInfo* mappings,
 124       std::map<int, base::MemoryMappedFile::Region>* regions) override;
 125 #else
 126   void GetAdditionalMappedFilesForChildProcess(
 127       const base::CommandLine& command_line,
 128       int child_process_id,
 129       content::FileDescriptorInfo* mappings) override;
 130 #endif  // defined(OS_ANDROID)
 131 #if defined(OS_ANDROID) && defined(VIDEO_HOLE)
 132   content::ExternalVideoSurfaceContainer*
 133   OverrideCreateExternalVideoSurfaceContainer(
 134       content::WebContents* web_contents) override;
 135 #endif  // defined(OS_ANDROID) && defined(VIDEO_HOLE)
 136
 137  protected:
 138   CastContentBrowserClient();
 139
 140  private:
 141   void AddNetworkHintsMessageFilter(int render_process_id,
 142                                     net::URLRequestContext* context);
 143
 144   net::X509Certificate* SelectClientCertificateOnIOThread(
 145       GURL requesting_url,
 146       int render_process_id);
 147
 148 #if !defined(OS_ANDROID)
 149   // Returns the crash signal FD corresponding to the current process type.
 150   int GetCrashSignalFD(const base::CommandLine& command_line);
 151
 152   // Creates a CrashHandlerHost instance for the given process type.
 153   breakpad::CrashHandlerHostLinux* CreateCrashHandlerHost(
 154       const std::string& process_type);
 155
 156   // A static cache to hold crash_handlers for each process_type
 157   std::map<std::string, breakpad::CrashHandlerHostLinux*> crash_handlers_;
 158 #endif
 159
 160   scoped_ptr<URLRequestContextFactory> url_request_context_factory_;
 161
 162   DISALLOW_COPY_AND_ASSIGN(CastContentBrowserClient);
 163 };
 164
 165 }  // namespace shell
 166 }  // namespace chromecast
 167
 168 #endif  // CHROMECAST_BROWSER_CAST_CONTENT_BROWSER_CLIENT_H_