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 namespace content {
   8
   9 SkBitmap* ContentRendererClient::GetSadPluginBitmap() {
  10   return NULL;
  11 }
  12
  13 SkBitmap* ContentRendererClient::GetSadWebViewBitmap() {
  14   return NULL;
  15 }
  16
  17 std::string ContentRendererClient::GetDefaultEncoding() {
  18   return std::string();
  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 NULL;
  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(RenderFrame* render_frame,
  46                                            const base::Closure& closure) {
  47   closure.Run();
  48 }
  49
  50 blink::WebMediaStreamCenter*
  51 ContentRendererClient::OverrideCreateWebMediaStreamCenter(
  52     blink::WebMediaStreamCenterClient* client) {
  53   return NULL;
  54 }
  55
  56 blink::WebRTCPeerConnectionHandler*
  57 ContentRendererClient::OverrideCreateWebRTCPeerConnectionHandler(
  58     blink::WebRTCPeerConnectionHandlerClient* client) {
  59   return NULL;
  60 }
  61
  62 blink::WebMIDIAccessor*
  63 ContentRendererClient::OverrideCreateMIDIAccessor(
  64     blink::WebMIDIAccessorClient* client) {
  65   return NULL;
  66 }
  67
  68 blink::WebAudioDevice*
  69 ContentRendererClient::OverrideCreateAudioDevice(
  70     double sample_rate) {
  71   return NULL;
  72 }
  73
  74 blink::WebClipboard* ContentRendererClient::OverrideWebClipboard() {
  75   return NULL;
  76 }
  77
  78 blink::WebThemeEngine* ContentRendererClient::OverrideThemeEngine() {
  79   return NULL;
  80 }
  81
  82 blink::WebSpeechSynthesizer* ContentRendererClient::OverrideSpeechSynthesizer(
  83     blink::WebSpeechSynthesizerClient* client) {
  84   return NULL;
  85 }
  86
  87 bool ContentRendererClient::RunIdleHandlerWhenWidgetsHidden() {
  88   return true;
  89 }
  90
  91 bool ContentRendererClient::AllowPopup() {
  92   return false;
  93 }
  94
  95 #ifdef OS_ANDROID
  96 bool ContentRendererClient::HandleNavigation(
  97     RenderFrame* render_frame,
  98     DocumentState* document_state,
  99     int opener_id,
 100     blink::WebFrame* frame,
 101     const blink::WebURLRequest& request,
 102     blink::WebNavigationType type,
 103     blink::WebNavigationPolicy default_policy,
 104     bool is_redirect) {
 105   return false;
 106 }
 107 #endif
 108
 109 bool ContentRendererClient::ShouldFork(blink::WebFrame* frame,
 110                                        const GURL& url,
 111                                        const std::string& http_method,
 112                                        bool is_initial_navigation,
 113                                        bool is_server_redirect,
 114                                        bool* send_referrer) {
 115   return false;
 116 }
 117
 118 bool ContentRendererClient::WillSendRequest(
 119     blink::WebFrame* frame,
 120     PageTransition transition_type,
 121     const GURL& url,
 122     const GURL& first_party_for_cookies,
 123     GURL* new_url) {
 124   return false;
 125 }
 126
 127 unsigned long long ContentRendererClient::VisitedLinkHash(
 128     const char* canonical_url, size_t length) {
 129   return 0LL;
 130 }
 131
 132 bool ContentRendererClient::IsLinkVisited(unsigned long long link_hash) {
 133   return false;
 134 }
 135
 136 blink::WebPrescientNetworking*
 137 ContentRendererClient::GetPrescientNetworking() {
 138   return NULL;
 139 }
 140
 141 bool ContentRendererClient::ShouldOverridePageVisibilityState(
 142     const RenderFrame* render_frame,
 143     blink::WebPageVisibilityState* override_state) {
 144   return false;
 145 }
 146
 147 const void* ContentRendererClient::CreatePPAPIInterface(
 148     const std::string& interface_name) {
 149   return NULL;
 150 }
 151
 152 bool ContentRendererClient::IsExternalPepperPlugin(
 153     const std::string& module_name) {
 154   return false;
 155 }
 156
 157 bool ContentRendererClient::AllowBrowserPlugin(
 158     blink::WebPluginContainer* container) {
 159   return false;
 160 }
 161
 162 bool ContentRendererClient::AllowPepperMediaStreamAPI(const GURL& url) {
 163   return false;
 164 }
 165
 166 void ContentRendererClient::AddKeySystems(
 167     std::vector<KeySystemInfo>* key_systems) {
 168 }
 169
 170 bool ContentRendererClient::ShouldReportDetailedMessageForSource(
 171     const base::string16& source) const {
 172   return false;
 173 }
 174
 175 bool ContentRendererClient::ShouldEnableSiteIsolationPolicy() const {
 176   return true;
 177 }
 178
 179 blink::WebWorkerPermissionClientProxy*
 180 ContentRendererClient::CreateWorkerPermissionClientProxy(
 181     RenderFrame* render_frame, blink::WebFrame* frame) {
 182   return NULL;
 183 }
 184
 185 }  // namespace content