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

Source/modules/screen_orientation/ScreenOrientation.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/ScreenOrientation.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
@@ skipping 25 matching lines @@
     DEFINE_STATIC_LOCAL(const AtomicString, portraitPrimary, ("portrait-primary", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, portraitSecondary, ("portrait-secondary", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, landscapePrimary, ("landscape-primary", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, landscapeSecondary, ("landscape-secondary", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, any, ("any", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, portrait, ("portrait", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, landscape, ("landscape", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, natural, ("natural", AtomicString::ConstructFromLiteral));
 
     static ScreenOrientationInfo orientationMap[] = {
-        { portraitPrimary, blink::WebScreenOrientationLockPortraitPrimary },
-        { portraitSecondary, blink::WebScreenOrientationLockPortraitSecondary },
-        { landscapePrimary, blink::WebScreenOrientationLockLandscapePrimary },
-        { landscapeSecondary, blink::WebScreenOrientationLockLandscapeSecondary },
-        { any, blink::WebScreenOrientationLockAny },
-        { portrait, blink::WebScreenOrientationLockPortrait },
-        { landscape, blink::WebScreenOrientationLockLandscape },
-        { natural, blink::WebScreenOrientationLockNatural }
+        { portraitPrimary, WebScreenOrientationLockPortraitPrimary },
+        { portraitSecondary, WebScreenOrientationLockPortraitSecondary },
+        { landscapePrimary, WebScreenOrientationLockLandscapePrimary },
+        { landscapeSecondary, WebScreenOrientationLockLandscapeSecondary },
+        { any, WebScreenOrientationLockAny },
+        { portrait, WebScreenOrientationLockPortrait },
+        { landscape, WebScreenOrientationLockLandscape },
+        { natural, WebScreenOrientationLockNatural }
     };
     length = WTF_ARRAY_LENGTH(orientationMap);
 
     return orientationMap;
 }
 
-const AtomicString& ScreenOrientation::orientationTypeToString(blink::WebScreenOrientationType orientation)
+const AtomicString& ScreenOrientation::orientationTypeToString(WebScreenOrientationType orientation)
 {
     unsigned length = 0;
     ScreenOrientationInfo* orientationMap = orientationsMap(length);
     for (unsigned i = 0; i < length; ++i) {
         if (static_cast<unsigned>(orientation) == orientationMap[i].orientation)
             return orientationMap[i].name;
     }
 
     ASSERT_NOT_REACHED();
     return nullAtom;
 }
 
-static blink::WebScreenOrientationLockType stringToOrientationLock(const AtomicString& orientationLockString)
+static WebScreenOrientationLockType stringToOrientationLock(const AtomicString& orientationLockString)
 {
     unsigned length = 0;
     ScreenOrientationInfo* orientationMap = orientationsMap(length);
     for (unsigned i = 0; i < length; ++i) {
         if (orientationMap[i].name == orientationLockString)
-            return static_cast<blink::WebScreenOrientationLockType>(orientationMap[i].orientation);
+            return static_cast<WebScreenOrientationLockType>(orientationMap[i].orientation);
     }
 
     ASSERT_NOT_REACHED();
-    return blink::WebScreenOrientationLockDefault;
+    return WebScreenOrientationLockDefault;
 }
 
 // static
 ScreenOrientation* ScreenOrientation::create(LocalFrame* frame)
 {
     ASSERT(frame);
 
     ScreenOrientation* orientation = adoptRefCountedGarbageCollectedWillBeNoop(new ScreenOrientation(frame));
     ASSERT(orientation->controller());
     // FIXME: ideally, we would like to provide the ScreenOrientationController
     // the case where it is not defined but for the moment, it is eagerly
     // created when the LocalFrame is created so we shouldn't be in that
     // situtaion.
     // In order to create the ScreenOrientationController lazily, we would need
     // to be able to access WebFrameClient from modules/.
 
     orientation->controller()->setOrientation(orientation);
     return orientation;
 }
 
 ScreenOrientation::ScreenOrientation(LocalFrame* frame)
     : DOMWindowProperty(frame)
-    , m_type(blink::WebScreenOrientationUndefined)
+    , m_type(WebScreenOrientationUndefined)
     , m_angle(0)
 {
     ScriptWrappable::init(this);
 }
 
 ScreenOrientation::~ScreenOrientation()
 {
 }
 
 const WTF::AtomicString& ScreenOrientation::interfaceName() const
@@ skipping 11 matching lines @@
 String ScreenOrientation::type() const
 {
     return orientationTypeToString(m_type);
 }
 
 unsigned short ScreenOrientation::angle() const
 {
     return m_angle;
 }
 
-void ScreenOrientation::setType(blink::WebScreenOrientationType type)
+void ScreenOrientation::setType(WebScreenOrientationType type)
 {
     m_type = type;
 }
 
 void ScreenOrientation::setAngle(unsigned short angle)
 {
     m_angle = angle;
 }
 
 ScriptPromise ScreenOrientation::lock(ScriptState* state, const AtomicString& lockString)
@@ skipping 34 matching lines @@
 
     return ScreenOrientationController::from(*m_frame);
 }
 
 void ScreenOrientation::trace(Visitor* visitor)
 {
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink