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