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