Cleanup namespace usage in Source/web/Web[A-H]*.cpp

Source/web/WebDevToolsAgentImpl.cpp

 /*
  * Copyright (C) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 56 matching lines @@
 #include "public/web/WebSettings.h"
 #include "public/web/WebViewClient.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/text/WTFString.h"
 
-using namespace blink;
-
 namespace OverlayZOrders {
 // Use 99 as a big z-order number so that highlight is above other overlays.
 static const int highlight = 99;
 }
 
 namespace blink {
 
 class ClientMessageLoopAdapter : public PageScriptDebugServer::ClientMessageLoop {
 public:
     static void ensureClientMessageLoopCreated(WebDevToolsAgentClient* client)
@@ skipping 12 matching lines @@
     }
 
     static void didNavigate()
     {
         // Release render thread if necessary.
         if (s_instance && s_instance->m_running)
             PageScriptDebugServer::shared().continueProgram();
     }
 
 private:
-    ClientMessageLoopAdapter(PassOwnPtr<blink::WebDevToolsAgentClient::WebKitClientMessageLoop> messageLoop)
+    ClientMessageLoopAdapter(PassOwnPtr<WebDevToolsAgentClient::WebKitClientMessageLoop> messageLoop)
         : m_running(false)
         , m_messageLoop(messageLoop) { }
 
 
     virtual void run(Page* page)
     {
         if (m_running)
             return;
         m_running = true;
 
@@ skipping 41 matching lines @@
 
         m_running = false;
     }
 
     virtual void quitNow()
     {
         m_messageLoop->quitNow();
     }
 
     bool m_running;
-    OwnPtr<blink::WebDevToolsAgentClient::WebKitClientMessageLoop> m_messageLoop;
+    OwnPtr<WebDevToolsAgentClient::WebKitClientMessageLoop> m_messageLoop;
     typedef HashSet<WebViewImpl*> FrozenViewsSet;
     FrozenViewsSet m_frozenViews;
     // FIXME: The ownership model for s_instance is somewhat complicated. Can we make this simpler?
     static ClientMessageLoopAdapter* s_instance;
 };
 
 ClientMessageLoopAdapter* ClientMessageLoopAdapter::s_instance = 0;
 
 class DebuggerTask : public PageScriptDebugServer::Task {
 public:
@@ skipping 37 matching lines @@
     inspectorController()->setProcessId(processId);
 
     ASSERT(m_debuggerId > 0);
     ClientMessageLoopAdapter::ensureClientMessageLoopCreated(m_client);
 }
 
 WebDevToolsAgentImpl::~WebDevToolsAgentImpl()
 {
     ClientMessageLoopAdapter::inspectedViewClosed(m_webViewImpl);
     if (m_attached)
-        blink::Platform::current()->currentThread()->removeTaskObserver(this);
+        Platform::current()->currentThread()->removeTaskObserver(this);
 }
 
 void WebDevToolsAgentImpl::attach(const WebString& hostId)
 {
     if (m_attached)
         return;
 
     inspectorController()->connectFrontend(hostId, this);
-    blink::Platform::current()->currentThread()->addTaskObserver(this);
+    Platform::current()->currentThread()->addTaskObserver(this);
     m_attached = true;
 }
 
 void WebDevToolsAgentImpl::reattach(const WebString& hostId, const WebString& savedState)
 {
     if (m_attached)
         return;
 
     inspectorController()->reuseFrontend(hostId, this, savedState);
-    blink::Platform::current()->currentThread()->addTaskObserver(this);
+    Platform::current()->currentThread()->addTaskObserver(this);
     m_attached = true;
 }
 
 void WebDevToolsAgentImpl::detach()
 {
-    blink::Platform::current()->currentThread()->removeTaskObserver(this);
+    Platform::current()->currentThread()->removeTaskObserver(this);
 
     // Prevent controller from sending messages to the frontend.
     InspectorController* ic = inspectorController();
     ic->disconnectFrontend();
     m_attached = false;
 }
 
 void WebDevToolsAgentImpl::continueProgram()
 {
     ClientMessageLoopAdapter::didNavigate();
@@ skipping 21 matching lines @@
 
 void WebDevToolsAgentImpl::didComposite()
 {
     TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "CompositeLayers");
     if (InspectorController* ic = inspectorController())
         ic->didComposite();
 }
 
 void WebDevToolsAgentImpl::didCreateScriptContext(WebLocalFrameImpl* webframe, int worldId)
 {
-    if (blink::LocalFrame* frame = webframe->frame())
+    if (LocalFrame* frame = webframe->frame())
         frame->script().setWorldDebugId(worldId, m_debuggerId);
     // Skip non main world contexts.
     if (worldId)
         return;
     m_webViewDidLayoutOnceAfterLoad = false;
 }
 
-bool WebDevToolsAgentImpl::handleInputEvent(blink::Page* page, const WebInputEvent& inputEvent)
+bool WebDevToolsAgentImpl::handleInputEvent(Page* page, const WebInputEvent& inputEvent)
 {
     if (!m_attached && !m_generatingEvent)
         return false;
 
     // FIXME: This workaround is required for touch emulation on Mac, where
     // compositor-side pinch handling is not enabled. See http://crbug.com/138003.
     bool isPinch = inputEvent.type == WebInputEvent::GesturePinchBegin || inputEvent.type == WebInputEvent::GesturePinchUpdate || inputEvent.type == WebInputEvent::GesturePinchEnd;
     if (isPinch && m_touchEventEmulationEnabled) {
         FrameView* frameView = page->deprecatedLocalMainFrame()->view();
         PlatformGestureEventBuilder gestureEvent(frameView, static_cast<const WebGestureEvent&>(inputEvent));
         float pageScaleFactor = page->pageScaleFactor();
         if (gestureEvent.type() == PlatformEvent::GesturePinchBegin) {
-            m_lastPinchAnchorCss = adoptPtr(new blink::IntPoint(frameView->scrollPosition() + gestureEvent.position()));
-            m_lastPinchAnchorDip = adoptPtr(new blink::IntPoint(gestureEvent.position()));
+            m_lastPinchAnchorCss = adoptPtr(new IntPoint(frameView->scrollPosition() + gestureEvent.position()));
+            m_lastPinchAnchorDip = adoptPtr(new IntPoint(gestureEvent.position()));
             m_lastPinchAnchorDip->scale(pageScaleFactor, pageScaleFactor);
         }
         if (gestureEvent.type() == PlatformEvent::GesturePinchUpdate && m_lastPinchAnchorCss) {
             float newPageScaleFactor = pageScaleFactor * gestureEvent.scale();
-            blink::IntPoint anchorCss(*m_lastPinchAnchorDip.get());
+            IntPoint anchorCss(*m_lastPinchAnchorDip.get());
             anchorCss.scale(1.f / newPageScaleFactor, 1.f / newPageScaleFactor);
             m_webViewImpl->setPageScaleFactor(newPageScaleFactor);
             m_webViewImpl->setMainFrameScrollOffset(*m_lastPinchAnchorCss.get() - toIntSize(anchorCss));
         }
         if (gestureEvent.type() == PlatformEvent::GesturePinchEnd) {
             m_lastPinchAnchorCss.clear();
             m_lastPinchAnchorDip.clear();
         }
         return true;
     }
@@ skipping 320 matching lines @@
         m_webViewImpl->layout();
     }
     m_webViewImpl->addPageOverlay(this, OverlayZOrders::highlight);
 }
 
 void WebDevToolsAgentImpl::hideHighlight()
 {
     m_webViewImpl->removePageOverlay(this);
 }
 
-void WebDevToolsAgentImpl::sendMessageToFrontend(PassRefPtr<blink::JSONObject> message)
+void WebDevToolsAgentImpl::sendMessageToFrontend(PassRefPtr<JSONObject> message)
 {
     m_frontendMessageQueue.append(message);
 }
 
 void WebDevToolsAgentImpl::flush()
 {
     flushPendingFrontendMessages();
 }
 
 void WebDevToolsAgentImpl::updateInspectorStateCookie(const String& state)
@@ skipping 61 matching lines @@
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_removeBreakpointCmd)
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointsActiveCmd);
 }
 
 void WebDevToolsAgent::processPendingMessages()
 {
     PageScriptDebugServer::shared().runPendingTasks();
 }
 
 } // namespace blink