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