Rename WebKit namespace to blink (part 4)

chrome/renderer/extensions/dispatcher.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 "chrome/renderer/extensions/dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/json/json_reader.h"
@@ skipping 85 matching lines @@
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 #if defined(ENABLE_WEBRTC)
 #include "chrome/renderer/extensions/webrtc_native_handler.h"
 #endif
 
-using WebKit::WebDataSource;
-using WebKit::WebDocument;
-using WebKit::WebFrame;
-using WebKit::WebScopedUserGesture;
-using WebKit::WebSecurityPolicy;
-using WebKit::WebString;
-using WebKit::WebVector;
-using WebKit::WebView;
+using blink::WebDataSource;
+using blink::WebDocument;
+using blink::WebFrame;
+using blink::WebScopedUserGesture;
+using blink::WebSecurityPolicy;
+using blink::WebString;
+using blink::WebVector;
+using blink::WebView;
 using content::RenderThread;
 using content::RenderView;
 
 namespace extensions {
 
 namespace {
 
 static const int64 kInitialExtensionIdleHandlerDelayMs = 5*1000;
 static const int64 kMaxExtensionIdleHandlerDelayMs = 5*60*1000;
 static const char kEventDispatchFunction[] = "dispatchEvent";
@@ skipping 54 matching lines @@
                    base::Unretained(this)));
     RouteFunction("RunWithoutUserGesture",
         base::Bind(&UserGesturesNativeHandler::RunWithoutUserGesture,
                    base::Unretained(this)));
   }
 
  private:
   void IsProcessingUserGesture(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     args.GetReturnValue().Set(v8::Boolean::New(
-        WebKit::WebUserGestureIndicator::isProcessingUserGesture()));
+        blink::WebUserGestureIndicator::isProcessingUserGesture()));
   }
 
   void RunWithUserGesture(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
-    WebKit::WebScopedUserGesture user_gesture;
+    blink::WebScopedUserGesture user_gesture;
     CHECK_EQ(args.Length(), 1);
     CHECK(args[0]->IsFunction());
     v8::Handle<v8::Value> no_args;
     context()->CallFunction(v8::Handle<v8::Function>::Cast(args[0]),
                             0, &no_args);
   }
 
   void RunWithoutUserGesture(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
-    WebKit::WebUserGestureIndicator::consumeUserGesture();
+    blink::WebUserGestureIndicator::consumeUserGesture();
     CHECK_EQ(args.Length(), 1);
     CHECK(args[0]->IsFunction());
     v8::Handle<v8::Value> no_args;
     context()->CallFunction(v8::Handle<v8::Function>::Cast(args[0]),
                             0, &no_args);
   }
 };
 
 class V8ContextNativeHandler : public ObjectBackedNativeHandler {
  public:
@@ skipping 1038 matching lines @@
     return;
 
   context->DispatchOnUnloadEvent();
   // TODO(kalman): add an invalidation observer interface to ChromeV8Context.
   request_sender_->InvalidateSource(context);
 
   v8_context_set_.Remove(context);
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
-void Dispatcher::DidCreateDocumentElement(WebKit::WebFrame* frame) {
+void Dispatcher::DidCreateDocumentElement(blink::WebFrame* frame) {
   if (IsWithinPlatformApp()) {
     // WebKit doesn't let us define an additional user agent stylesheet, so we
     // insert the default platform app stylesheet into all documents that are
     // loaded in each app.
     std::string stylesheet =
         ResourceBundle::GetSharedInstance().
             GetRawDataResource(IDR_PLATFORM_APP_CSS).as_string();
     ReplaceFirstSubstringAfterOffset(&stylesheet, 0,
                                      "$FONTFAMILY", system_font_family_);
     ReplaceFirstSubstringAfterOffset(&stylesheet, 0,
                                      "$FONTSIZE", system_font_size_);
     frame->document().insertUserStyleSheet(
         WebString::fromUTF8(stylesheet), WebDocument::UserStyleUserLevel);
   }
 
   content_watcher_->DidCreateDocumentElement(frame);
 }
 
 void Dispatcher::DidMatchCSS(
-    WebKit::WebFrame* frame,
-    const WebKit::WebVector<WebKit::WebString>& newly_matching_selectors,
-    const WebKit::WebVector<WebKit::WebString>& stopped_matching_selectors) {
+    blink::WebFrame* frame,
+    const blink::WebVector<blink::WebString>& newly_matching_selectors,
+    const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   content_watcher_->DidMatchCSS(
       frame, newly_matching_selectors, stopped_matching_selectors);
 }
 
 
 void Dispatcher::OnActivateExtension(const std::string& extension_id) {
   const Extension* extension = extensions_.GetByID(extension_id);
   if (!extension) {
     // Extension was activated but was never loaded. This probably means that
     // the renderer failed to load it (or the browser failed to tell us when it
@@ skipping 61 matching lines @@
               extension->url(),
               WebString::fromUTF8(schemes[j]),
               WebString::fromUTF8(i->host()),
               i->match_subdomains());
       }
     }
   }
 }
 
 void Dispatcher::EnableCustomElementWhiteList() {
-  WebKit::WebRuntimeFeatures::enableEmbedderCustomElements(true);
-  WebKit::WebCustomElement::addEmbedderCustomElementName("webview");
+  blink::WebRuntimeFeatures::enableEmbedderCustomElements(true);
+  blink::WebCustomElement::addEmbedderCustomElementName("webview");
   // TODO(fsamuel): Add <adview> to the whitelist once it has been converted
   // into a custom element.
-  WebKit::WebCustomElement::addEmbedderCustomElementName("browser-plugin");
+  blink::WebCustomElement::addEmbedderCustomElementName("browser-plugin");
 }
 
 void Dispatcher::AddOrRemoveBindings(const std::string& extension_id) {
   v8_context_set().ForEach(
       extension_id,
       NULL,  // all render views
       base::Bind(&Dispatcher::AddOrRemoveBindingsForContext,
                  base::Unretained(this)));
 }
 
@@ skipping 118 matching lines @@
       return SandboxedPageInfo::IsSandboxedPage(extension, url.path());
     }
   }
   return false;
 }
 
 Feature::Context Dispatcher::ClassifyJavaScriptContext(
     const std::string& extension_id,
     int extension_group,
     const GURL& url,
-    const WebKit::WebSecurityOrigin& origin) {
+    const blink::WebSecurityOrigin& origin) {
   DCHECK_GE(extension_group, 0);
   if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS) {
     return extensions_.Contains(extension_id) ?
         Feature::CONTENT_SCRIPT_CONTEXT : Feature::UNSPECIFIED_CONTEXT;
   }
 
   // We have an explicit check for sandboxed pages before checking whether the
   // extension is active in this process because:
   // 1. Sandboxed pages run in the same process as regular extension pages, so
   //    the extension is considered active.
@@ skipping 35 matching lines @@
   }
 
   if (!context->extension()) {
     v8::ThrowException(
         v8::Exception::Error(v8::String::New("Not in an extension.")));
     return false;
   }
 
   // Theoretically we could end up with bindings being injected into sandboxed
   // frames, for example content scripts. Don't let them execute API functions.
-  WebKit::WebFrame* frame = context->web_frame();
+  blink::WebFrame* frame = context->web_frame();
   if (IsSandboxedPage(UserScriptSlave::GetDataSourceURLForFrame(frame))) {
     static const char kMessage[] =
         "%s cannot be used within a sandboxed frame.";
     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
     v8::ThrowException(
         v8::Exception::Error(v8::String::New(error_msg.c_str())));
     return false;
   }
 
   Feature::Availability availability = context->GetAvailability(function_name);
@@ skipping 54 matching lines @@
     RenderView* background_view =
         ExtensionHelper::GetBackgroundPage(extension_id);
     if (background_view) {
       background_view->Send(new ExtensionHostMsg_EventAck(
           background_view->GetRoutingID()));
     }
   }
 }
 
 }  // namespace extensions