Add initial Blink-side support for the Screen Orientation API

Source/modules/screen_orientation/ScreenOrientation.cpp

Index: Source/modules/screen_orientation/ScreenOrientation.cpp
diff --git a/Source/modules/screen_orientation/ScreenOrientation.cpp b/Source/modules/screen_orientation/ScreenOrientation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bdb8bb78a393150506701635963c733b0c1ecabb
--- /dev/null
+++ b/Source/modules/screen_orientation/ScreenOrientation.cpp
@@ -0,0 +1,216 @@
+// 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 "ScreenOrientation.h"
+
+#include "core/frame/Frame.h"
+#include "core/frame/Screen.h"
+#include "core/page/ChromeClient.h"
+#include "modules/screen_orientation/ScreenOrientationClient.h"
+#include "modules/screen_orientation/ScreenOrientationController.h"
+
+namespace WebCore {
+
+ScreenOrientation::ScreenOrientation(Screen* screen)
+    : DOMWindowProperty(screen->frame())
+    , PageLifecycleObserver(page())
+    , ActiveDOMObject(frame() ? frame()->document() : 0)
+    , m_screen(screen)
+    , m_orientationLockTimer(this, &ScreenOrientation::orientationLockTimerFired)
+    , m_lockedOrientations(OrientationAny)
+{
+    ASSERT(screen);

[Peter Beverloo, 2014/02/12 18:19:37]

We'd already have crashed if !screen, since you're calling Screen::frame() on it
as part of the DOMWindowProperty initialization.  Under what circumstances would
!screen occur?

[Inactive, 2014/02/12 19:38:37]

Good point, I will move this assertion to the caller.

+    ScreenOrientationController* controller = ScreenOrientationController::from(page());
+    if (controller)
+        controller->addObserver(this);
+}
+
+ScreenOrientation::~ScreenOrientation()
+{
+}
+
+const char* ScreenOrientation::supplementName()
+{
+    return "ScreenOrientation";
+}
+
+void ScreenOrientation::orientationLockTimerFired(Timer<ScreenOrientation>*)
+{
+    ScreenOrientationClient* client = ScreenOrientationController::clientFrom(page());
+    if (!client)
+        return;
+
+    client->lockOrientation(m_lockedOrientations);
+}
+
+void ScreenOrientation::didCommitLoad(Frame*)
+{
+    // New page loaded, unlock screen orientation.
+    unlockOrientation();
+}
+
+void ScreenOrientation::willDestroyGlobalObjectInFrame()
+{
+    m_screen = 0;
+    DOMWindowProperty::willDestroyGlobalObjectInFrame();
+}
+
+void ScreenOrientation::willDetachGlobalObjectFromFrame()
+{
+    m_screen = 0;
+    DOMWindowProperty::willDetachGlobalObjectFromFrame();
+}
+
+void ScreenOrientation::stop()
+{
+    ScreenOrientationController* controller = ScreenOrientationController::from(page());
+    if (controller)
+        controller->removeObserver(this);
+}
+
+Page* ScreenOrientation::page() const
+{
+    return frame() ? frame()->page() : 0;
+}
+
+ScreenOrientation* ScreenOrientation::from(Screen* screen)
+{
+    ScreenOrientation* supplement = static_cast<ScreenOrientation*>(Supplement<Screen>::from(screen, supplementName()));
+    if (!supplement) {
+        supplement = new ScreenOrientation(screen);

[Peter Beverloo, 2014/02/12 18:19:37]

If you do need to ASSERT(screen), this would be a nice place to do it since the
constructor is private.

[Inactive, 2014/02/12 19:38:37]

Done.

+        supplement->suspendIfNeeded();
+        provideTo(screen, supplementName(), adoptPtr(supplement));
+    }
+    return supplement;
+}
+
+struct ScreenOrientationInfo {
+    const AtomicString& name;
+    ScreenOrientationValues orientation;
+};
+
+static ScreenOrientationInfo* allowedOrientationsMap(unsigned& length)
+{
+    DEFINE_STATIC_LOCAL(const AtomicString, portrait, ("portrait", AtomicString::ConstructFromLiteral));
+    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, landscape, ("landscape", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, landscapePrimary, ("landscape-primary", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, landscapeSecondary, ("landscape-secondary", AtomicString::ConstructFromLiteral));
+
+    static ScreenOrientationInfo orientationMap[] = {
+        { portrait, OrientationPortrait },
+        { portraitPrimary, OrientationPortraitPrimary },
+        { portraitSecondary, OrientationPortraitSecondary },
+        { landscape, OrientationLandscape },
+        { landscapePrimary, OrientationLandscapePrimary },
+        { landscapeSecondary, OrientationLandscapeSecondary }
+    };
+    length = WTF_ARRAY_LENGTH(orientationMap);
+    return orientationMap;
+}
+
+const AtomicString& ScreenOrientation::orientationToString(ScreenOrientationValue orientation)
+{
+    unsigned length = 0;
+    ScreenOrientationInfo* orientationMap = allowedOrientationsMap(length);
+    for (unsigned i = 0; i < length; ++i) {
+        if (orientationMap[i].orientation == orientation)
+            return orientationMap[i].name;
+    }
+    ASSERT_NOT_REACHED();

[Peter Beverloo, 2014/02/12 18:19:37]

nit: maybe add a note that OrientationInvalid and OrientationAny are not being
handled, but that that's fine because the incoming value needs to be in the
WebScreenOrientation enum as well, which doesn't define them?

[Inactive, 2014/02/12 19:38:37]

Done.

+    return nullAtom;
+}
+
+ScreenOrientationValues ScreenOrientation::stringToOrientationValues(const AtomicString& orientation)
+{
+    unsigned length = 0;
+    ScreenOrientationInfo* orientationMap = allowedOrientationsMap(length);
+    for (unsigned i = 0; i < length; ++i) {
+        if (orientationMap[i].name == orientation)
+            return orientationMap[i].orientation;
+    }
+    return OrientationInvalid;
+}
+
+const AtomicString& ScreenOrientation::orientation(Screen* screen)
+{
+    ScreenOrientation* screenOrientation = ScreenOrientation::from(screen);
+    ASSERT(screenOrientation);
+
+    ScreenOrientationController* controller = ScreenOrientationController::from(screenOrientation->page());
+    if (!controller)
+        return orientationToString(OrientationPortraitPrimary);
+
+    return orientationToString(controller->orientation());
+}
+
+bool ScreenOrientation::lockOrientation(Screen* screen, const Vector<String>& orientationsVector)
+{
+    ScreenOrientationValues orientations = OrientationInvalid;
+
+    for (unsigned i = 0; i < orientationsVector.size(); ++i) {
+        ScreenOrientationValues inputOrientation = stringToOrientationValues(AtomicString(orientationsVector[i]));
+        if (inputOrientation == OrientationInvalid)
+            return false;
+        orientations |= inputOrientation;
+    }
+
+    if (!orientations)
+        return false;
+
+    ScreenOrientation* screenOrientation = ScreenOrientation::from(screen);
+    ASSERT(screenOrientation);
+    screenOrientation->lockOrientationAsync(orientations);
+    return true;
+}
+
+bool ScreenOrientation::lockOrientation(Screen* screen, const AtomicString& orientationString)
+{
+    ScreenOrientationValues orientation = stringToOrientationValues(orientationString);
+    if (!orientation)
+        return false;
+
+    ScreenOrientation* screenOrientation = ScreenOrientation::from(screen);
+    ASSERT(screenOrientation);
+    screenOrientation->lockOrientationAsync(orientation);
+    return true;
+}
+
+void ScreenOrientation::lockOrientationAsync(ScreenOrientationValues orientations)
+{
+    ASSERT(!(orientations & OrientationInvalid));
+
+    m_lockedOrientations = orientations;
+    if (!m_orientationLockTimer.isActive())
+        m_orientationLockTimer.startOneShot(0);

[mlamouri (slow - plz ping), 2014/02/12 20:11:26]

I do not think having this call async here is really useful. Given that we will
likely cross process boundaries, locking will be async anyway. What we really
care about is that the orientationchange event is sent asynchronously compared
to the lockOrientation() call. Why not specifying this in
WebScreenOrientationClient to make sure the implementation keep
lockOrientation() async?

[Inactive, 2014/02/12 21:08:04]

I am not sure about this one. I think this is a quite common way of making sure
we do the task asynchronously, as mandated by the spec. I am slightly worried
about making assumptions about crossing process boundaries. As you can see
already, it is not the case for my mock client and I would have to move this
Timer there anyway.

[mlamouri (slow - plz ping), 2014/02/13 16:12:08]

I guess I will let the Webkit/Blink experienced folks decide here. Though, I am
not saying that IPC will do the job just that we should let the embedder take
care of the asynchronous part. Forcing the Blink bits to be async would simply
slow down things IMO. It might be bad for responsiveness. Also, note that
unlockOrientation() does not seem to follow that rule (ie. it is sync).

[Inactive, 2014/02/13 16:32:26]

Yes, I asked for clarification on the spec about unlockOrientation():
https://www.w3.org/Bugs/Public/show_bug.cgi?id=24614

+}
+
+void ScreenOrientation::unlockOrientation(Screen* screen)
+{
+    ScreenOrientation* screenOrientation = ScreenOrientation::from(screen);
+    ASSERT(screenOrientation);
+    screenOrientation->unlockOrientation();
+}
+
+void ScreenOrientation::unlockOrientation()
+{
+    if (m_lockedOrientations == OrientationAny)
+        return; // Not currently locked.

[mlamouri (slow - plz ping), 2014/02/12 20:11:26]

This is actually a false assumption. I believe that the specification says that
unlockOrientation() should revert the lock to the default which can be anything.
For example, on most Android applications, it will be: [ 'portrait-primary',
'landscape' ].

[Inactive, 2014/02/12 21:08:04]

Well, we are not locked due to JS. Why pass call unlockOrientation() on the
client if the JS did not previously lock the orientation?

[mlamouri (slow - plz ping), 2014/02/13 16:12:08]

This code would be call if |screen.unlockOrientation| is called, right? It seems
that there are a lot of ways to have a broken behaviour here.

+
+    m_lockedOrientations = OrientationAny;

[mlamouri (slow - plz ping), 2014/02/12 20:11:26]

Generally speaking, I think you can get ride of m_lockedOrientations. It does
not seem needed.

[mlamouri (slow - plz ping), 2014/02/12 20:11:26]

I

[Inactive, 2014/02/12 21:08:04]

I need it as long as I keep locking asynchronously via the
m_orientationLockTimer timer. See my comment about why I'd prefer to keep the
Timer.

[mlamouri (slow - plz ping), 2014/02/13 16:12:08]

Sadly, indeed.

+
+    ScreenOrientationClient* client = ScreenOrientationController::clientFrom(page());
+    if (client)
+        client->unlockOrientation();
+}
+
+void ScreenOrientation::orientationChanged()
+{
+    if (m_screen)
+        m_screen->dispatchEvent(Event::create(EventTypeNames::orientationchange));
+}
+
+} // namespace WebCore