Screen Orientation API: screen.orientation & orientationchange event

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/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()
 {
     return "ScreenOrientation";
 }
 
 ScreenOrientation* ScreenOrientation::from(Screen* screen)
 {
     ScreenOrientation* supplement = static_cast<ScreenOrientation*>(Supplement<Screen>::from(screen, supplementName()));
     if (!supplement) {
         ASSERT(screen);
         supplement = new ScreenOrientation(screen);
         provideTo(screen, supplementName(), adoptPtr(supplement));
     }
     return supplement;
 }
 
 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
 {
     Frame* frame = this->frame();
     ASSERT(frame);
     DOMWindow* window = frame->domWindow();
     ASSERT(window);
     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.

 }
 
+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.

+{
+    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;
+    }
+    // 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)
 {
-    // FIXME: Implement.
-    DEFINE_STATIC_LOCAL(const AtomicString, portraitPrimary, ("portrait-primary", AtomicString::ConstructFromLiteral));
-    return portraitPrimary;
+    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)
 {
     // FIXME: Implement.
     return false;
 }
 
 bool ScreenOrientation::lockOrientation(Screen* screen, const AtomicString& orientation)
 {
     // FIXME: Implement.
     return false;
 }
 
 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