Rename WebKit namespace to blink (part 3)

content/public/renderer/content_renderer_client.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/public/renderer/content_renderer_client.h"
 
 namespace content {
 
 SkBitmap* ContentRendererClient::GetSadPluginBitmap() {
   return NULL;
 }
 
 SkBitmap* ContentRendererClient::GetSadWebViewBitmap() {
   return NULL;
 }
 
 std::string ContentRendererClient::GetDefaultEncoding() {
   return std::string();
 }
 
 bool ContentRendererClient::OverrideCreatePlugin(
     RenderView* render_view,
-    WebKit::WebFrame* frame,
-    const WebKit::WebPluginParams& params,
-    WebKit::WebPlugin** plugin) {
+    blink::WebFrame* frame,
+    const blink::WebPluginParams& params,
+    blink::WebPlugin** plugin) {
   return false;
 }
 
-WebKit::WebPlugin* ContentRendererClient::CreatePluginReplacement(
+blink::WebPlugin* ContentRendererClient::CreatePluginReplacement(
     RenderView* render_view,
     const base::FilePath& plugin_path) {
   return NULL;
 }
 
 bool ContentRendererClient::HasErrorPage(int http_status_code,
                                          std::string* error_domain) {
   return false;
 }
 
 bool ContentRendererClient::ShouldSuppressErrorPage(const GURL& url) {
   return false;
 }
 
 void ContentRendererClient::DeferMediaLoad(RenderView* render_view,
                                            const base::Closure& closure) {
   closure.Run();
 }
 
-WebKit::WebMediaStreamCenter*
+blink::WebMediaStreamCenter*
 ContentRendererClient::OverrideCreateWebMediaStreamCenter(
-    WebKit::WebMediaStreamCenterClient* client) {
+    blink::WebMediaStreamCenterClient* client) {
   return NULL;
 }
 
-WebKit::WebRTCPeerConnectionHandler*
+blink::WebRTCPeerConnectionHandler*
 ContentRendererClient::OverrideCreateWebRTCPeerConnectionHandler(
-    WebKit::WebRTCPeerConnectionHandlerClient* client) {
+    blink::WebRTCPeerConnectionHandlerClient* client) {
   return NULL;
 }
 
-WebKit::WebMIDIAccessor*
+blink::WebMIDIAccessor*
 ContentRendererClient::OverrideCreateMIDIAccessor(
-    WebKit::WebMIDIAccessorClient* client) {
+    blink::WebMIDIAccessorClient* client) {
   return NULL;
 }
 
-WebKit::WebAudioDevice*
+blink::WebAudioDevice*
 ContentRendererClient::OverrideCreateAudioDevice(
     double sample_rate) {
   return NULL;
 }
 
-WebKit::WebClipboard* ContentRendererClient::OverrideWebClipboard() {
+blink::WebClipboard* ContentRendererClient::OverrideWebClipboard() {
   return NULL;
 }
 
-WebKit::WebThemeEngine* ContentRendererClient::OverrideThemeEngine() {
+blink::WebThemeEngine* ContentRendererClient::OverrideThemeEngine() {
   return NULL;
 }
 
-WebKit::WebSpeechSynthesizer* ContentRendererClient::OverrideSpeechSynthesizer(
-    WebKit::WebSpeechSynthesizerClient* client) {
+blink::WebSpeechSynthesizer* ContentRendererClient::OverrideSpeechSynthesizer(
+    blink::WebSpeechSynthesizerClient* client) {
   return NULL;
 }
 
 bool ContentRendererClient::RunIdleHandlerWhenWidgetsHidden() {
   return true;
 }
 
 bool ContentRendererClient::AllowPopup() {
   return false;
 }
 
 bool ContentRendererClient::HandleNavigation(
-    WebKit::WebFrame* frame,
-    const WebKit::WebURLRequest& request,
-    WebKit::WebNavigationType type,
-    WebKit::WebNavigationPolicy default_policy,
+    blink::WebFrame* frame,
+    const blink::WebURLRequest& request,
+    blink::WebNavigationType type,
+    blink::WebNavigationPolicy default_policy,
     bool is_redirect) {
   return false;
 }
 
-bool ContentRendererClient::ShouldFork(WebKit::WebFrame* frame,
+bool ContentRendererClient::ShouldFork(blink::WebFrame* frame,
                                        const GURL& url,
                                        const std::string& http_method,
                                        bool is_initial_navigation,
                                        bool is_server_redirect,
                                        bool* send_referrer) {
   return false;
 }
 
 bool ContentRendererClient::WillSendRequest(
-    WebKit::WebFrame* frame,
+    blink::WebFrame* frame,
     PageTransition transition_type,
     const GURL& url,
     const GURL& first_party_for_cookies,
     GURL* new_url) {
   return false;
 }
 
 bool ContentRendererClient::ShouldPumpEventsDuringCookieMessage() {
   return false;
 }
 
 unsigned long long ContentRendererClient::VisitedLinkHash(
     const char* canonical_url, size_t length) {
   return 0LL;
 }
 
 bool ContentRendererClient::IsLinkVisited(unsigned long long link_hash) {
   return false;
 }
 
-WebKit::WebPrescientNetworking*
+blink::WebPrescientNetworking*
 ContentRendererClient::GetPrescientNetworking() {
   return NULL;
 }
 
 bool ContentRendererClient::ShouldOverridePageVisibilityState(
     const RenderView* render_view,
-    WebKit::WebPageVisibilityState* override_state) {
+    blink::WebPageVisibilityState* override_state) {
   return false;
 }
 
 bool ContentRendererClient::HandleGetCookieRequest(
     RenderView* sender,
     const GURL& url,
     const GURL& first_party_for_cookies,
     std::string* cookies) {
   return false;
 }
@@ skipping 10 matching lines @@
     const std::string& interface_name) {
   return NULL;
 }
 
 bool ContentRendererClient::IsExternalPepperPlugin(
     const std::string& module_name) {
   return false;
 }
 
 bool ContentRendererClient::IsPluginAllowedToCallRequestOSFileHandle(
-    WebKit::WebPluginContainer* container) {
+    blink::WebPluginContainer* container) {
   return false;
 }
 
 bool ContentRendererClient::AllowBrowserPlugin(
-    WebKit::WebPluginContainer* container) {
+    blink::WebPluginContainer* container) {
   return false;
 }
 
 bool ContentRendererClient::AllowPepperMediaStreamAPI(const GURL& url) {
   return false;
 }
 
 void ContentRendererClient::AddKeySystems(
     std::vector<KeySystemInfo>* key_systems) {
 }
 
 bool ContentRendererClient::ShouldReportDetailedMessageForSource(
     const base::string16& source) const {
   return false;
 }
 
 bool ContentRendererClient::ShouldEnableSiteIsolationPolicy() const {
   return true;
 }
 
-WebKit::WebWorkerPermissionClientProxy*
+blink::WebWorkerPermissionClientProxy*
 ContentRendererClient::CreateWorkerPermissionClientProxy(
-    RenderView* render_view, WebKit::WebFrame* frame) {
+    RenderView* render_view, blink::WebFrame* frame) {
   return NULL;
 }
 
 }  // namespace content