Cleanup blink:: prefix usage in Source/core/modules/[mediasource/*.cpp to websockets/*.cpp]

Source/modules/screen_orientation/ScreenOrientationController.cpp

 // Copyright 2014 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 "config.h"
 #include "modules/screen_orientation/ScreenOrientationController.h"
 
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/page/Page.h"
 #include "modules/screen_orientation/ScreenOrientation.h"
 #include "modules/screen_orientation/ScreenOrientationDispatcher.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/PlatformScreen.h"
 #include "public/platform/WebScreenOrientationClient.h"
 
 namespace blink {
 
 ScreenOrientationController::~ScreenOrientationController()
 {
 }
 
 void ScreenOrientationController::persistentHostHasBeenDestroyed()
 {
     // Unregister lifecycle observation once page is being torn down.
     observeContext(0);
 }
 
-void ScreenOrientationController::provideTo(LocalFrame& frame, blink::WebScreenOrientationClient* client)
+void ScreenOrientationController::provideTo(LocalFrame& frame, WebScreenOrientationClient* client)
 {
     ASSERT(RuntimeEnabledFeatures::screenOrientationEnabled());
 
     ScreenOrientationController* controller = new ScreenOrientationController(frame, client);
     WillBeHeapSupplement<LocalFrame>::provideTo(frame, supplementName(), adoptPtrWillBeNoop(controller));
 }
 
 ScreenOrientationController* ScreenOrientationController::from(LocalFrame& frame)
 {
     return static_cast<ScreenOrientationController*>(WillBeHeapSupplement<LocalFrame>::from(frame, supplementName()));
 }
 
-ScreenOrientationController::ScreenOrientationController(LocalFrame& frame, blink::WebScreenOrientationClient* client)
+ScreenOrientationController::ScreenOrientationController(LocalFrame& frame, WebScreenOrientationClient* client)
     : PlatformEventController(frame.page())
     , m_client(client)
     , m_frame(frame)
     , m_dispatchEventTimer(this, &ScreenOrientationController::dispatchEventTimerFired)
 {
 }
 
 const char* ScreenOrientationController::supplementName()
 {
     return "ScreenOrientationController";
 }
 
 // Compute the screen orientation using the orientation angle and the screen width / height.
-blink::WebScreenOrientationType ScreenOrientationController::computeOrientation(FrameView* view)
+WebScreenOrientationType ScreenOrientationController::computeOrientation(FrameView* view)
 {
     // Bypass orientation detection in layout tests to get consistent results.
     // FIXME: The screen dimension should be fixed when running the layout tests to avoid such
     // issues.
     if (LayoutTestSupport::isRunningLayoutTest())
-        return blink::WebScreenOrientationPortraitPrimary;
+        return WebScreenOrientationPortraitPrimary;
 
     FloatRect rect = screenRect(view);
     uint16_t rotation = screenOrientationAngle(view);
     bool isTallDisplay = rotation % 180 ? rect.height() < rect.width() : rect.height() > rect.width();
     switch (rotation) {
     case 0:
-        return isTallDisplay ? blink::WebScreenOrientationPortraitPrimary : blink::WebScreenOrientationLandscapePrimary;
+        return isTallDisplay ? WebScreenOrientationPortraitPrimary : WebScreenOrientationLandscapePrimary;
     case 90:
-        return isTallDisplay ? blink::WebScreenOrientationLandscapePrimary : blink::WebScreenOrientationPortraitSecondary;
+        return isTallDisplay ? WebScreenOrientationLandscapePrimary : WebScreenOrientationPortraitSecondary;
     case 180:
-        return isTallDisplay ? blink::WebScreenOrientationPortraitSecondary : blink::WebScreenOrientationLandscapeSecondary;
+        return isTallDisplay ? WebScreenOrientationPortraitSecondary : WebScreenOrientationLandscapeSecondary;
     case 270:
-        return isTallDisplay ? blink::WebScreenOrientationLandscapeSecondary : blink::WebScreenOrientationPortraitPrimary;
+        return isTallDisplay ? WebScreenOrientationLandscapeSecondary : WebScreenOrientationPortraitPrimary;
     default:
         ASSERT_NOT_REACHED();
-        return blink::WebScreenOrientationPortraitPrimary;
+        return WebScreenOrientationPortraitPrimary;
     }
 }
 
 void ScreenOrientationController::updateOrientation()
 {
     ASSERT(m_orientation);
 
-    blink::WebScreenOrientationType orientationType = screenOrientationType(m_frame.view());
-    if (orientationType == blink::WebScreenOrientationUndefined) {
+    WebScreenOrientationType orientationType = screenOrientationType(m_frame.view());
+    if (orientationType == WebScreenOrientationUndefined) {
         // The embedder could not provide us with an orientation, deduce it ourselves.
         orientationType = computeOrientation(m_frame.view());
     }
-    ASSERT(orientationType != blink::WebScreenOrientationUndefined);
+    ASSERT(orientationType != WebScreenOrientationUndefined);
 
     m_orientation->setType(orientationType);
     m_orientation->setAngle(screenOrientationAngle(m_frame.view()));
 }
 
 void ScreenOrientationController::pageVisibilityChanged()
 {
     notifyDispatcher();
 
     if (!m_orientation || !page() || page()->visibilityState() != PageVisibilityStateVisible)
@@ skipping 43 matching lines @@
 }
 
 void ScreenOrientationController::setOrientation(ScreenOrientation* orientation)
 {
     m_orientation = orientation;
     if (m_orientation)
         updateOrientation();
     notifyDispatcher();
 }
 
-void ScreenOrientationController::lock(blink::WebScreenOrientationLockType orientation, blink::WebLockOrientationCallback* callback)
+void ScreenOrientationController::lock(WebScreenOrientationLockType orientation, WebLockOrientationCallback* callback)
 {
     ASSERT(m_client);
     m_client->lockOrientation(orientation, callback);
 }
 
 void ScreenOrientationController::unlock()
 {
     ASSERT(m_client);
     m_client->unlockOrientation();
 }
@@ skipping 38 matching lines @@
         stopUpdating();
 }
 
 void ScreenOrientationController::trace(Visitor* visitor)
 {
     visitor->trace(m_orientation);
     WillBeHeapSupplement<LocalFrame>::trace(visitor);
 }
 
 } // namespace blink