Use Promises for screen.lockOrientation().

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/v8/ExceptionState.h"
+#include "bindings/v8/ScriptPromise.h"
+#include "bindings/v8/ScriptPromiseResolverWithContext.h"
+#include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
+#include "core/dom/ExceptionCode.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Screen.h"
+#include "modules/screen_orientation/LockOrientationCallback.h"
 #include "modules/screen_orientation/ScreenOrientationController.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScreenOrientationType.h"
 
 // This code assumes that WebScreenOrientationType values are included in WebScreenOrientationLockType.
 #define COMPILE_ASSERT_MATCHING_ENUM(enum1, enum2) \
     COMPILE_ASSERT(static_cast<unsigned>(blink::enum1) == static_cast<unsigned>(blink::enum2), mismatching_types)
 COMPILE_ASSERT_MATCHING_ENUM(WebScreenOrientationPortraitPrimary, WebScreenOrientationLockPortraitPrimary);
 COMPILE_ASSERT_MATCHING_ENUM(WebScreenOrientationPortraitSecondary, WebScreenOrientationLockPortraitSecondary);
 COMPILE_ASSERT_MATCHING_ENUM(WebScreenOrientationLandscapePrimary, WebScreenOrientationLockLandscapePrimary);
@@ skipping 23 matching lines @@
         { landscapeSecondary, blink::WebScreenOrientationLockLandscapeSecondary },
         { any, blink::WebScreenOrientationLockAny },
         { portrait, blink::WebScreenOrientationLockPortrait },
         { landscape, blink::WebScreenOrientationLockLandscape }
     };
     length = WTF_ARRAY_LENGTH(orientationMap);
 
     return orientationMap;
 }
 
-static const AtomicString& orientationTypeToString(blink::WebScreenOrientationType orientation)
+const AtomicString& ScreenOrientation::orientationTypeToString(blink::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)
 {
     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);
     }
 
     ASSERT_NOT_REACHED();
     return blink::WebScreenOrientationLockDefault;
 }
 
 ScreenOrientation::ScreenOrientation(Screen& screen)
     : DOMWindowProperty(screen.frame())
-    , m_orientationLockTimer(this, &ScreenOrientation::orientationLockTimerFired)
-    , m_prospectiveLock(blink::WebScreenOrientationLockDefault)
 {
 }
 
-void ScreenOrientation::lockOrientationAsync(blink::WebScreenOrientationLockType orientation)
-{
-    if (m_orientationLockTimer.isActive())
-        m_orientationLockTimer.stop();
-
-    m_prospectiveLock = orientation;
-    m_orientationLockTimer.startOneShot(0, FROM_HERE);
-}
-
-void ScreenOrientation::orientationLockTimerFired(Timer<ScreenOrientation>*)
-{
-    if (m_prospectiveLock == blink::WebScreenOrientationLockDefault)
-        blink::Platform::current()->unlockOrientation();
-    else
-        blink::Platform::current()->lockOrientation(m_prospectiveLock);
-}
-
 const char* ScreenOrientation::supplementName()
 {
     return "ScreenOrientation";
 }
 
 Document* ScreenOrientation::document() const
 {
     if (!m_associatedDOMWindow || !m_associatedDOMWindow->isCurrentlyDisplayedInFrame())
         return 0;
     ASSERT(m_associatedDOMWindow->document());
@@ skipping 18 matching lines @@
 {
     ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
     if (!screenOrientation.document()) {
         // FIXME: we should try to return a better guess, like the latest known value.
         return orientationTypeToString(blink::WebScreenOrientationPortraitPrimary);
     }
     ScreenOrientationController& controller = ScreenOrientationController::from(*screenOrientation.document());
     return orientationTypeToString(controller.orientation());
 }
 
-bool ScreenOrientation::lockOrientation(Screen& screen, const AtomicString& lockString, ExceptionState& exceptionState)
+ScriptPromise ScreenOrientation::lockOrientation(ScriptState* state, Screen& screen, const AtomicString& lockString)
 {
+    RefPtr<ScriptPromiseResolverWithContext> resolver = ScriptPromiseResolverWithContext::create(state);
+    ScriptPromise promise = resolver->promise();
+
     ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
     Document* document = screenOrientation.document();
-    if (!document)
-        return false;
+
+    if (!document) {
+        RefPtrWillBeRawPtr<DOMException> exception = DOMException::create(InvalidStateError, "The object is no longer associated to a document.");
+        resolver->reject(exception);
+        return promise;
+    }
+
     if (document->isSandboxed(SandboxOrientationLock)) {
-        exceptionState.throwSecurityError("The document is sandboxed and lacks the 'allow-orientation-lock' flag.");
-        return false;
+        RefPtrWillBeRawPtr<DOMException> exception = DOMException::create(SecurityError, "The document is sandboxed and lacks the 'allow-orientation-lock' flag.");
+        resolver->reject(exception);
+        return promise;
     }
-    screenOrientation.lockOrientationAsync(stringToOrientationLock(lockString));
-    return true;
+
+    blink::Platform::current()->lockOrientation(stringToOrientationLock(lockString), new LockOrientationCallback(resolver));
+    return promise;
 }
 
 void ScreenOrientation::unlockOrientation(Screen& screen)
 {
-    ScreenOrientation::from(screen).lockOrientationAsync(blink::WebScreenOrientationLockDefault);
+    blink::Platform::current()->unlockOrientation();
 }
 
 } // namespace WebCore