Rename WebKit namespace to blink (part 3)

content/public/test/render_view_test.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/test/render_view_test.h"
 
 #include "base/run_loop.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
@@ skipping 10 matching lines @@
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebScreenInfo.h"
 #include "third_party/WebKit/public/web/WebScriptController.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/glue/webkit_glue.h"
 
-using WebKit::WebFrame;
-using WebKit::WebInputEvent;
-using WebKit::WebMouseEvent;
-using WebKit::WebScriptController;
-using WebKit::WebScriptSource;
-using WebKit::WebString;
-using WebKit::WebURLRequest;
+using blink::WebFrame;
+using blink::WebInputEvent;
+using blink::WebMouseEvent;
+using blink::WebScriptController;
+using blink::WebScriptSource;
+using blink::WebString;
+using blink::WebURLRequest;
 
 namespace {
 const int32 kOpenerId = -2;
 const int32 kRouteId = 5;
 const int32 kMainFrameRouteId = 6;
 const int32 kNewWindowRouteId = 7;
 const int32 kSurfaceId = 42;
 
 }  // namespace
 
 namespace content {
 
 class RendererWebKitPlatformSupportImplNoSandboxImpl
     : public RendererWebKitPlatformSupportImpl {
  public:
-  virtual WebKit::WebSandboxSupport* sandboxSupport() {
+  virtual blink::WebSandboxSupport* sandboxSupport() {
     return NULL;
   }
 };
 
 RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::
     RendererWebKitPlatformSupportImplNoSandbox() {
   webkit_platform_support_.reset(
       new RendererWebKitPlatformSupportImplNoSandboxImpl());
 }
 
 RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::
     ~RendererWebKitPlatformSupportImplNoSandbox() {
 }
 
-WebKit::Platform*
+blink::Platform*
     RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::Get() {
   return webkit_platform_support_.get();
 }
 
 RenderViewTest::RenderViewTest()
     : view_(NULL) {
 }
 
 RenderViewTest::~RenderViewTest() {
 }
@@ skipping 31 matching lines @@
   url_str.append(html);
   GURL url(url_str);
 
   GetMainFrame()->loadRequest(WebURLRequest(url));
 
   // The load actually happens asynchronously, so we pump messages to process
   // the pending continuation.
   ProcessPendingMessages();
 }
 
-void RenderViewTest::GoBack(const WebKit::WebHistoryItem& item) {
+void RenderViewTest::GoBack(const blink::WebHistoryItem& item) {
   GoToOffset(-1, item);
 }
 
-void RenderViewTest::GoForward(const WebKit::WebHistoryItem& item) {
+void RenderViewTest::GoForward(const blink::WebHistoryItem& item) {
   GoToOffset(1, item);
 }
 
 void RenderViewTest::SetUp() {
   // Subclasses can set the ContentClient's renderer before calling
   // RenderViewTest::SetUp().
   ContentRendererClient* old_client =
       SetRendererClientForTesting(&content_renderer_client_);
   if (old_client)
     SetRendererClientForTesting(old_client);
 
   // Subclasses can set render_thread_ with their own implementation before
   // calling RenderViewTest::SetUp().
   if (!render_thread_)
     render_thread_.reset(new MockRenderThread());
   render_thread_->set_routing_id(kRouteId);
   render_thread_->set_surface_id(kSurfaceId);
   render_thread_->set_new_window_routing_id(kNewWindowRouteId);
 
   command_line_.reset(new CommandLine(CommandLine::NO_PROGRAM));
   params_.reset(new MainFunctionParams(*command_line_));
   platform_.reset(new RendererMainPlatformDelegate(*params_));
   platform_->PlatformInitialize();
 
   // Setting flags and really doing anything with WebKit is fairly fragile and
   // hacky, but this is the world we live in...
   webkit_glue::SetJavaScriptFlags(" --expose-gc");
-  WebKit::initialize(webkit_platform_support_.Get());
+  blink::initialize(webkit_platform_support_.Get());
 
   // Ensure that we register any necessary schemes when initializing WebKit,
   // since we are using a MockRenderThread.
   RenderThreadImpl::RegisterSchemes();
 
   // This check is needed because when run under content_browsertests,
   // ResourceBundle isn't initialized (since we have to use a diferent test
   // suite implementation than for content_unittests). For browser_tests, this
   // is already initialized.
   if (!ResourceBundle::HasSharedInstance())
     ResourceBundle::InitSharedInstanceWithLocale("en-US", NULL);
 
   mock_process_.reset(new MockRenderProcess);
 
   // This needs to pass the mock render thread to the view.
   RenderViewImpl* view = RenderViewImpl::Create(
       kOpenerId,
       RendererPreferences(),
       WebPreferences(),
       kRouteId,
       kMainFrameRouteId,
       kSurfaceId,
       kInvalidSessionStorageNamespaceId,
       string16(),
       false, // is_renderer_created
       false, // swapped_out
       false, // hidden
       1, // next_page_id
-      WebKit::WebScreenInfo(),
+      blink::WebScreenInfo(),
       AccessibilityModeOff,
       true);
   view->AddRef();
   view_ = view;
 }
 
 void RenderViewTest::TearDown() {
   // Try very hard to collect garbage before shutting down.
   // "5" was chosen following http://crbug.com/46571#c9
   const int kGCIterations = 5;
   for (int i = 0; i < kGCIterations; i++)
     GetMainFrame()->collectGarbage();
 
   // Run the loop so the release task from the renderwidget executes.
   ProcessPendingMessages();
 
   for (int i = 0; i < kGCIterations; i++)
     GetMainFrame()->collectGarbage();
 
   render_thread_->SendCloseMessage();
   view_ = NULL;
   mock_process_.reset();
 
   // After telling the view to close and resetting mock_process_ we may get
   // some new tasks which need to be processed before shutting down WebKit
   // (http://crbug.com/21508).
   base::RunLoop().RunUntilIdle();
 
-  WebKit::shutdown();
+  blink::shutdown();
 
   platform_->PlatformUninitialize();
   platform_.reset();
   params_.reset();
   command_line_.reset();
 }
 
 void RenderViewTest::SendNativeKeyEvent(
     const NativeWebKeyboardEvent& key_event) {
   SendWebKeyboardEvent(key_event);
 }
 
 void RenderViewTest::SendWebKeyboardEvent(
-    const WebKit::WebKeyboardEvent& key_event) {
+    const blink::WebKeyboardEvent& key_event) {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->OnMessageReceived(
       InputMsg_HandleInputEvent(0, &key_event, ui::LatencyInfo(), false));
 }
 
 void RenderViewTest::SendWebMouseEvent(
-    const WebKit::WebMouseEvent& mouse_event) {
+    const blink::WebMouseEvent& mouse_event) {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->OnMessageReceived(
       InputMsg_HandleInputEvent(0, &mouse_event, ui::LatencyInfo(), false));
 }
 
 const char* const kGetCoordinatesScript =
     "(function() {"
     "  function GetCoordinates(elem) {"
     "    if (!elem)"
     "      return [ 0, 0];"
@@ skipping 47 matching lines @@
   mouse_event.x = bounds.CenterPoint().x();
   mouse_event.y = bounds.CenterPoint().y();
   mouse_event.clickCount = 1;
   scoped_ptr<IPC::Message> input_message(
       new InputMsg_HandleInputEvent(0, &mouse_event, ui::LatencyInfo(), false));
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->OnMessageReceived(*input_message);
   return true;
 }
 
-void RenderViewTest::SetFocused(const WebKit::WebNode& node) {
+void RenderViewTest::SetFocused(const blink::WebNode& node) {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->focusedNodeChanged(node);
 }
 
 void RenderViewTest::ClearHistory() {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->page_id_ = -1;
   impl->history_list_offset_ = -1;
   impl->history_list_length_ = 0;
   impl->history_page_ids_.clear();
 }
 
 void RenderViewTest::Reload(const GURL& url) {
   ViewMsg_Navigate_Params params;
   params.url = url;
   params.navigation_type = ViewMsg_Navigate_Type::RELOAD;
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->OnNavigate(params);
 }
 
 uint32 RenderViewTest::GetNavigationIPCType() {
   return ViewHostMsg_FrameNavigate::ID;
 }
 
 void RenderViewTest::Resize(gfx::Size new_size,
                             gfx::Rect resizer_rect,
                             bool is_fullscreen) {
   ViewMsg_Resize_Params params;
-  params.screen_info = WebKit::WebScreenInfo();
+  params.screen_info = blink::WebScreenInfo();
   params.new_size = new_size;
   params.physical_backing_size = new_size;
   params.overdraw_bottom_height = 0.f;
   params.resizer_rect = resizer_rect;
   params.is_fullscreen = is_fullscreen;
   scoped_ptr<IPC::Message> resize_message(new ViewMsg_Resize(0, params));
   OnMessageReceived(*resize_message);
 }
 
 bool RenderViewTest::OnMessageReceived(const IPC::Message& msg) {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   return impl->OnMessageReceived(msg);
 }
 
-void RenderViewTest::DidNavigateWithinPage(WebKit::WebFrame* frame,
+void RenderViewTest::DidNavigateWithinPage(blink::WebFrame* frame,
                                            bool is_new_navigation) {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->didNavigateWithinPage(frame, is_new_navigation);
 }
 
 void RenderViewTest::SendContentStateImmediately() {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->set_send_content_state_immediately(true);
 }
 
-WebKit::WebWidget* RenderViewTest::GetWebWidget() {
+blink::WebWidget* RenderViewTest::GetWebWidget() {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   return impl->webwidget();
 }
 
 void RenderViewTest::GoToOffset(int offset,
-                                const WebKit::WebHistoryItem& history_item) {
+                                const blink::WebHistoryItem& history_item) {
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
 
   int history_list_length = impl->historyBackListCount() +
                             impl->historyForwardListCount() + 1;
   int pending_offset = offset + impl->history_list_offset();
 
   ViewMsg_Navigate_Params navigate_params;
   navigate_params.navigation_type = ViewMsg_Navigate_Type::NORMAL;
   navigate_params.transition = PAGE_TRANSITION_FORWARD_BACK;
   navigate_params.current_history_list_length = history_list_length;
   navigate_params.current_history_list_offset = impl->history_list_offset();
   navigate_params.pending_history_list_offset = pending_offset;
   navigate_params.page_id = impl->GetPageId() + offset;
   navigate_params.page_state = HistoryItemToPageState(history_item);
   navigate_params.request_time = base::Time::Now();
 
   ViewMsg_Navigate navigate_message(impl->GetRoutingID(), navigate_params);
   OnMessageReceived(navigate_message);
 
   // The load actually happens asynchronously, so we pump messages to process
   // the pending continuation.
   ProcessPendingMessages();
 }
 
 }  // namespace content