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