Screen Orientation API: screen.orientation & orientationchange event

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
index 4b147dd809a0f4ee807ee0cd9fb9fe5145c8ce0e..a1f653741bded7ccbb73cce37d345a7f0b2fbce5 100644
--- a/Source/modules/screen_orientation/ScreenOrientation.cpp
+++ b/Source/modules/screen_orientation/ScreenOrientation.cpp
@@ -5,15 +5,19 @@
 #include "config.h"
 #include "modules/screen_orientation/ScreenOrientation.h"
 
+#include "core/events/Event.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/Frame.h"
 #include "core/frame/Screen.h"
+#include "modules/screen_orientation/ScreenOrientationController.h"
 
 namespace WebCore {
 
 ScreenOrientation::ScreenOrientation(Screen* screen)
     : DOMWindowProperty(screen->frame())
 {
+    if (ScreenOrientationController* controller = ScreenOrientationController::from(page()))
+        controller->addObserver(this);

[abarth-chromium, 2014/02/18 01:34:27]

Under what circumstances can |controller| be zero.  I'd be include to ASSERT
that |controller| is non-zero and make it an error to construct a
ScreenOrientation object in those circumstances.

[Inactive, 2014/02/18 20:52:47]

Done. No longer needed now that the controller is listening for changes and
firing events (similarly to DeviceOrientation module).

 }
 
 const char* ScreenOrientation::supplementName()
@@ -34,6 +38,8 @@ ScreenOrientation* ScreenOrientation::from(Screen* screen)
 
 ScreenOrientation::~ScreenOrientation()
 {
+    if (ScreenOrientationController* controller = ScreenOrientationController::from(page()))

[Inactive, 2014/02/17 18:23:13]

I looked at the Geolocation module and it subclasses ActiveDOMObject, then
overrides stop() and unregisters from the controller in stop() instead of the
destructor. Please let me know if you think I should do the same here.

+        controller->removeObserver(this);

[abarth-chromium, 2014/02/18 01:34:27]

I believe the correct thing to do is to override willDetachGlobalObjectFromFrame
and remove the observer then.  Removing the observer should be unconditional. 
We want both the addObserver and removeObserver calls to be unconditional so
that we know they balance.

 }
 
 Screen* ScreenOrientation::screen() const
@@ -45,11 +51,56 @@ Screen* ScreenOrientation::screen() const
     return window->screen();

[abarth-chromium, 2014/02/18 01:34:27]

Why not just:

return m_associatedDOMWindow->screen();

[Inactive, 2014/02/18 20:52:47]

This function is no longer needed now that the controller fires the event.

 }
 
-const AtomicString& ScreenOrientation::orientation(Screen* screen)
+struct ScreenOrientationInfo {
+    const AtomicString& name;
+    ScreenOrientationValues orientation;
+};
+
+static ScreenOrientationInfo* allowedOrientationsMap(unsigned& length)

[abarth-chromium, 2014/02/18 01:34:27]

Please put free static functions at the top of the file.

[Inactive, 2014/02/18 20:52:47]

Done.

 {
-    // FIXME: Implement.
+    DEFINE_STATIC_LOCAL(const AtomicString, portrait, ("portrait", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(const AtomicString, portraitPrimary, ("portrait-primary", AtomicString::ConstructFromLiteral));
-    return portraitPrimary;
+    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;
+    }
+    // We do no handle OrientationInvalid and OrientationAny but this is fine be cause screen.orientation
+    // should never return these and WebScreenOrientation does not define those values.
+    ASSERT_NOT_REACHED();
+    return nullAtom;
+}
+
+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>& orientations)
@@ -69,4 +120,17 @@ void ScreenOrientation::unlockOrientation(Screen* screen)
     // FIXME: Implement.
 }
 
+void ScreenOrientation::orientationChanged()
+{
+    ASSERT(screen());
+    screen()->dispatchEvent(Event::create(EventTypeNames::orientationchange));
+}
+
+Page* ScreenOrientation::page() const
+{
+    Frame* frame = this->frame();
+    ASSERT(frame);
+    return frame->page();
+}
+
 } // namespace WebCore