content/public/renderer/content_renderer_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 "content/public/renderer/content_renderer_client.h"
   6
   7 #include "content/public/renderer/media_stream_renderer_factory.h"
   8 #include "media/base/renderer_factory.h"
   9 #include "third_party/WebKit/public/platform/modules/app_banner/WebAppBannerClient.h"
  10 #include "third_party/WebKit/public/web/WebPluginPlaceholder.h"
  11
  12 namespace content {
  13
  14 SkBitmap* ContentRendererClient::GetSadPluginBitmap() {
  15   return nullptr;
  16 }
  17
  18 SkBitmap* ContentRendererClient::GetSadWebViewBitmap() {
  19   return nullptr;
  20 }
  21
  22 scoped_ptr<blink::WebPluginPlaceholder>
  23 ContentRendererClient::CreatePluginPlaceholder(
  24     RenderFrame* render_frame,
  25     blink::WebLocalFrame* frame,
  26     const blink::WebPluginParams& params) {
  27   return nullptr;
  28 }
  29
  30 bool ContentRendererClient::OverrideCreatePlugin(
  31     RenderFrame* render_frame,
  32     blink::WebLocalFrame* frame,
  33     const blink::WebPluginParams& params,
  34     blink::WebPlugin** plugin) {
  35   return false;
  36 }
  37
  38 blink::WebPlugin* ContentRendererClient::CreatePluginReplacement(
  39     RenderFrame* render_frame,
  40     const base::FilePath& plugin_path) {
  41   return nullptr;
  42 }
  43
  44 bool ContentRendererClient::HasErrorPage(int http_status_code,
  45                                          std::string* error_domain) {
  46   return false;
  47 }
  48
  49 bool ContentRendererClient::ShouldSuppressErrorPage(RenderFrame* render_frame,
  50                                                     const GURL& url) {
  51   return false;
  52 }
  53
  54 void ContentRendererClient::DeferMediaLoad(RenderFrame* render_frame,
  55                                            const base::Closure& closure) {
  56   closure.Run();
  57 }
  58
  59 blink::WebMediaStreamCenter*
  60 ContentRendererClient::OverrideCreateWebMediaStreamCenter(
  61     blink::WebMediaStreamCenterClient* client) {
  62   return nullptr;
  63 }
  64
  65 blink::WebRTCPeerConnectionHandler*
  66 ContentRendererClient::OverrideCreateWebRTCPeerConnectionHandler(
  67     blink::WebRTCPeerConnectionHandlerClient* client) {
  68   return nullptr;
  69 }
  70
  71 blink::WebMIDIAccessor*
  72 ContentRendererClient::OverrideCreateMIDIAccessor(
  73     blink::WebMIDIAccessorClient* client) {
  74   return nullptr;
  75 }
  76
  77 blink::WebAudioDevice*
  78 ContentRendererClient::OverrideCreateAudioDevice(
  79     double sample_rate) {
  80   return nullptr;
  81 }
  82
  83 blink::WebClipboard* ContentRendererClient::OverrideWebClipboard() {
  84   return nullptr;
  85 }
  86
  87 blink::WebThemeEngine* ContentRendererClient::OverrideThemeEngine() {
  88   return nullptr;
  89 }
  90
  91 blink::WebSpeechSynthesizer* ContentRendererClient::OverrideSpeechSynthesizer(
  92     blink::WebSpeechSynthesizerClient* client) {
  93   return nullptr;
  94 }
  95
  96 bool ContentRendererClient::RunIdleHandlerWhenWidgetsHidden() {
  97   return true;
  98 }
  99
 100 bool ContentRendererClient::AllowPopup() {
 101   return false;
 102 }
 103
 104 bool ContentRendererClient::ShouldFork(blink::WebLocalFrame* frame,
 105                                        const GURL& url,
 106                                        const std::string& http_method,
 107                                        bool is_initial_navigation,
 108                                        bool is_server_redirect,
 109                                        bool* send_referrer) {
 110   return false;
 111 }
 112
 113 bool ContentRendererClient::WillSendRequest(
 114     blink::WebFrame* frame,
 115     ui::PageTransition transition_type,
 116     const GURL& url,
 117     const GURL& first_party_for_cookies,
 118     GURL* new_url) {
 119   return false;
 120 }
 121
 122 unsigned long long ContentRendererClient::VisitedLinkHash(
 123     const char* canonical_url, size_t length) {
 124   return 0LL;
 125 }
 126
 127 bool ContentRendererClient::IsLinkVisited(unsigned long long link_hash) {
 128   return false;
 129 }
 130
 131 blink::WebPrescientNetworking*
 132 ContentRendererClient::GetPrescientNetworking() {
 133   return nullptr;
 134 }
 135
 136 bool ContentRendererClient::ShouldOverridePageVisibilityState(
 137     const RenderFrame* render_frame,
 138     blink::WebPageVisibilityState* override_state) {
 139   return false;
 140 }
 141
 142 const void* ContentRendererClient::CreatePPAPIInterface(
 143     const std::string& interface_name) {
 144   return nullptr;
 145 }
 146
 147 bool ContentRendererClient::IsExternalPepperPlugin(
 148     const std::string& module_name) {
 149   return false;
 150 }
 151
 152 bool ContentRendererClient::AllowPepperMediaStreamAPI(const GURL& url) {
 153   return false;
 154 }
 155
 156 void ContentRendererClient::AddKeySystems(
 157     std::vector<media::KeySystemInfo>* key_systems) {
 158 }
 159
 160 scoped_ptr<media::RendererFactory>
 161 ContentRendererClient::CreateMediaRendererFactory(
 162     RenderFrame* render_frame,
 163     const scoped_refptr<media::GpuVideoAcceleratorFactories>& gpu_factories,
 164     const scoped_refptr<media::MediaLog>& media_log) {
 165   return nullptr;
 166 }
 167
 168 scoped_ptr<MediaStreamRendererFactory>
 169 ContentRendererClient::CreateMediaStreamRendererFactory() {
 170   return nullptr;
 171 }
 172
 173 bool ContentRendererClient::ShouldReportDetailedMessageForSource(
 174     const base::string16& source) const {
 175   return false;
 176 }
 177
 178 bool ContentRendererClient::ShouldGatherSiteIsolationStats() const {
 179   return true;
 180 }
 181
 182 blink::WebWorkerContentSettingsClientProxy*
 183 ContentRendererClient::CreateWorkerContentSettingsClientProxy(
 184     RenderFrame* render_frame, blink::WebFrame* frame) {
 185   return nullptr;
 186 }
 187
 188 bool ContentRendererClient::IsPluginAllowedToUseCameraDeviceAPI(
 189     const GURL& url) {
 190   return false;
 191 }
 192
 193 bool ContentRendererClient::IsPluginAllowedToUseCompositorAPI(const GURL& url) {
 194   return false;
 195 }
 196
 197 bool ContentRendererClient::IsPluginAllowedToUseDevChannelAPIs() {
 198   return false;
 199 }
 200
 201 BrowserPluginDelegate* ContentRendererClient::CreateBrowserPluginDelegate(
 202     RenderFrame* render_frame,
 203     const std::string& mime_type,
 204     const GURL& original_url) {
 205   return nullptr;
 206 }
 207
 208 std::string ContentRendererClient::GetUserAgentOverrideForURL(const GURL& url) {
 209   return std::string();
 210 }
 211
 212 scoped_ptr<blink::WebAppBannerClient>
 213 ContentRendererClient::CreateAppBannerClient(RenderFrame* render_frame) {
 214   return nullptr;
 215 }
 216
 217 }  // namespace content