Screen Orientation API: cleanup, simplify and fix implementation.

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 "core/frame/DOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Screen.h"
 #include "modules/screen_orientation/ScreenOrientationController.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebScreenOrientationType.h"
 
 namespace WebCore {
 
-static const unsigned WebScreenOrientationDefault = 0;
-
 struct ScreenOrientationInfo {
     const AtomicString& name;
-    blink::WebScreenOrientation orientation;
+    char orientation;

[Inactive, 2014/03/31 18:52:36]

Any reason we are not using a WebScreenOrientationLockType here? It seems you
initialize only with WebScreenOrientationLockType values.

[mlamouri (slow - plz ping), 2014/03/31 19:45:35]

I could put WebScreenOrientationLockType but it would give the false impression
that it should only be used for that. I don't care much TBH.

 };
 
 static ScreenOrientationInfo* orientationsMap(unsigned& length)
 {
     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));
 
     static ScreenOrientationInfo orientationMap[] = {
-        { portraitPrimary, blink::WebScreenOrientationPortraitPrimary },
-        { portraitSecondary, blink::WebScreenOrientationPortraitSecondary },
-        { landscapePrimary, blink::WebScreenOrientationLandscapePrimary },
-        { landscapeSecondary, blink::WebScreenOrientationLandscapeSecondary }
+        { portraitPrimary, blink::WebScreenOrientationLockPortraitPrimary },
+        { portraitSecondary, blink::WebScreenOrientationLockPortraitSecondary },
+        { landscapePrimary, blink::WebScreenOrientationLockLandscapePrimary },
+        { landscapeSecondary, blink::WebScreenOrientationLockLandscapeSecondary },
+        { any, blink::WebScreenOrientationLockAny },
+        { portrait, blink::WebScreenOrientationLockPortrait },
+        { landscape, blink::WebScreenOrientationLockLandscape }
     };
     length = WTF_ARRAY_LENGTH(orientationMap);
+
     return orientationMap;
 }
 
-static const AtomicString& orientationToString(blink::WebScreenOrientation orientation)
+static const AtomicString& orientationTypeToString(blink::WebScreenOrientationType orientation)
 {
     unsigned length = 0;
     ScreenOrientationInfo* orientationMap = orientationsMap(length);
     for (unsigned i = 0; i < length; ++i) {
-        if (orientationMap[i].orientation == orientation)
+        if (static_cast<blink::WebScreenOrientationType>(orientationMap[i].orientation) == orientation)

[Inactive, 2014/03/31 18:52:36]

So we rely on the values shared by WebScreenOrientationLockType and
WebScreenOrientationType to be the same. This looks fragile, especially without
compile-time assertions.

Also, the map contains values that are no valid WebScreenOrientationType values
(i.e. WebScreenOrientationLockAny and following). We should probably assert
against this before casting.

[mlamouri (slow - plz ping), 2014/03/31 19:45:35]

Argh. I meant to add compile time checks but I forgot.. Will update that.
Regarding values not valid for WebScreenOrientationType, given that we get the
orientation from the embedder, we could probably trust the value. Actually, we
get a value and we want a string. It sounds just not possible to not get what we
want. Assuming we have that compile check.

             return orientationMap[i].name;
     }
+
     // We do no handle OrientationInvalid and OrientationAny but this is fine because screen.orientation
     // should never return these and WebScreenOrientation does not define those values.
     ASSERT_NOT_REACHED();
     return nullAtom;
 }
 
-static blink::WebScreenOrientations stringToOrientations(const AtomicString& orientationString)
+static blink::WebScreenOrientationLockType stringToOrientationLock(const AtomicString& orientationLockString)
 {
-    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));
-
-    if (orientationString == any) {
-        return blink::WebScreenOrientationPortraitPrimary | blink::WebScreenOrientationPortraitSecondary |
-            blink::WebScreenOrientationLandscapePrimary | blink::WebScreenOrientationLandscapeSecondary;
-    }
-    if (orientationString == portrait)
-        return blink::WebScreenOrientationPortraitPrimary | blink::WebScreenOrientationPortraitSecondary;
-    if (orientationString == landscape)
-        return blink::WebScreenOrientationLandscapePrimary | blink::WebScreenOrientationLandscapeSecondary;
-
     unsigned length = 0;
     ScreenOrientationInfo* orientationMap = orientationsMap(length);
     for (unsigned i = 0; i < length; ++i) {
-        if (orientationMap[i].name == orientationString)
-            return orientationMap[i].orientation;
+        if (orientationMap[i].name == orientationLockString)
+            return static_cast<blink::WebScreenOrientationLockType>(orientationMap[i].orientation);
     }
-    return 0;
+
+    ASSERT_NOT_REACHED();
+    return blink::WebScreenOrientationLockDefault;
 }
 
 ScreenOrientation::ScreenOrientation(Screen& screen)
     : DOMWindowProperty(screen.frame())
     , m_orientationLockTimer(this, &ScreenOrientation::orientationLockTimerFired)
-    , m_lockedOrientations(WebScreenOrientationDefault)
+    , m_prospectiveLock(blink::WebScreenOrientationLockDefault)
 {
 }
 
-void ScreenOrientation::lockOrientationAsync(blink::WebScreenOrientations orientations)
+void ScreenOrientation::lockOrientationAsync(blink::WebScreenOrientationLockType orientation)
 {
-    if (m_lockedOrientations == orientations)
-        return;
-    m_lockedOrientations = orientations;
-    if (!m_orientationLockTimer.isActive())
-        m_orientationLockTimer.startOneShot(0, FROM_HERE);
+    if (m_orientationLockTimer.isActive())
+        m_orientationLockTimer.stop();
+
+    m_prospectiveLock = orientation;
+    m_orientationLockTimer.startOneShot(0, FROM_HERE);

[Inactive, 2014/03/31 18:52:36]

So consecutive calls to lockOrientation("portrait") are going to call into the
platform each time? There used to be a m_lockedOrientations == orientations
early return to protect against this.

[mlamouri (slow - plz ping), 2014/03/31 19:45:35]

If another ScreenOrientation instance lock the screen to some value,
m_lockedOrientations == orientations would falsely early return.

Also, a behaviour we want is that the following code locks to portrait:
screen.lockOrientation('landscape');
screen.lockOrientation('portrait');

It seems that the current code would lock to 'landscape'.

[Inactive, 2014/03/31 19:59:42]

What do you mean by another ScreenOrientation instance?

Why would the existing code lock to landscape? The second call would override
the value of m_lockedOrientations member before the timer has fired, right?

 }
 
 void ScreenOrientation::orientationLockTimerFired(Timer<ScreenOrientation>*)
 {
-    if (m_lockedOrientations == WebScreenOrientationDefault)
+    if (m_prospectiveLock == blink::WebScreenOrientationLockDefault)
         blink::Platform::current()->unlockOrientation();
     else
-        blink::Platform::current()->lockOrientation(m_lockedOrientations);
+        blink::Platform::current()->lockOrientation(m_prospectiveLock);
 }
 
 const char* ScreenOrientation::supplementName()
 {
     return "ScreenOrientation";
 }
 
 Document* ScreenOrientation::document() const
 {
     if (!m_associatedDOMWindow || !m_associatedDOMWindow->isCurrentlyDisplayedInFrame())
@@ skipping 14 matching lines @@
 
 ScreenOrientation::~ScreenOrientation()
 {
 }
 
 const AtomicString& ScreenOrientation::orientation(Screen& screen)
 {
     ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
     if (!screenOrientation.document()) {
         // FIXME: we should try to return a better guess, like the latest known value.
-        return orientationToString(blink::WebScreenOrientationPortraitPrimary);
+        return orientationTypeToString(blink::WebScreenOrientationPortraitPrimary);
     }
     ScreenOrientationController& controller = ScreenOrientationController::from(*screenOrientation.document());
-    return orientationToString(controller.orientation());
+    return orientationTypeToString(controller.orientation());
 }
 
-bool ScreenOrientation::lockOrientation(Screen& screen, const AtomicString& orientationString)
+bool ScreenOrientation::lockOrientation(Screen& screen, const AtomicString& lockString)
 {
-    blink::WebScreenOrientations orientations = stringToOrientations(orientationString);
-    if (!orientations)
-        return false;
-    ScreenOrientation::from(screen).lockOrientationAsync(orientations);
+    ScreenOrientation::from(screen).lockOrientationAsync(stringToOrientationLock(lockString));
     return true;
 }
 
 void ScreenOrientation::unlockOrientation(Screen& screen)
 {
-    ScreenOrientation::from(screen).lockOrientationAsync(WebScreenOrientationDefault);
+    ScreenOrientation::from(screen).lockOrientationAsync(blink::WebScreenOrientationLockDefault);
 }
 
 } // namespace WebCore