Add initial Blink-side support for the Screen Orientation API

Source/modules/screen_orientation/ScreenOrientationController.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 "ScreenOrientationController.h"
+
+#include "modules/screen_orientation/ScreenOrientationClient.h"
+
+namespace WebCore {
+
+ScreenOrientationController::ScreenOrientationController(ScreenOrientationClient* client)
+    : m_client(client)
+    // FIXME: This orientation is not necessary the right one until the first orientationchange
+    // event is fired.

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

What could we do to fix that? Would that be reasonable to mark m_orientation as
unset so if orientation is requested, it could be explicitly requested unless a
new value was provided?

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

Yes, we could then initialize m_orientation to OrientationInvalid and request
the orientation from the client if it is requested and m_orientation is invalid.
Sadly, this would have to be synchronous, right? (since screen.orientation
returns the orientation synchronously).

However, right now I have no support for requesting the orientation from the
client so I have to initialize it to something valid.

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

Let's solve that in a follow-up.

+    , m_orientation(OrientationPortraitPrimary)

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

Does that mean that if a page is loaded in another orientation than
'portrait-primary', an orientationchange event will be fired even if the
orientation never changed?

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

I don't think it would, as there would be no orientation change according to the
client. However, the issue would be if the device is then rotated from
'landscape-primary' to 'portrait-primary'. We likely won't fire an event because
the controller will think we are already in "portrait-primary". So yes, we have
to handle this better. I think initializing to an invalid / unknown orientation
is a good idea. The question is what should I do if screen.orientation is
accessed and I do not know the current orientation. I think it would be bad to
add a method to request the orientation from the client as this would mean a
synchronous call and this is likely to happen on application startup.

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

And that.

+    , m_hasClientForTest(false)
+{
+}
+
+PassOwnPtr<ScreenOrientationController> ScreenOrientationController::create(ScreenOrientationClient* client)
+{
+    return adoptPtr(new ScreenOrientationController(client));
+}
+
+void ScreenOrientationController::addObserver(ScreenOrientation* observer)
+{
+    m_observers.add(observer);
+}
+
+void ScreenOrientationController::removeObserver(ScreenOrientation* observer)
+{
+    m_observers.remove(observer);
+}
+
+const char* ScreenOrientationController::supplementName()
+{
+    return "ScreenOrientationController";
+}
+
+ScreenOrientationClient* ScreenOrientationController::clientFrom(Page* page)
+{
+    if (ScreenOrientationController* controller = ScreenOrientationController::from(page))
+        return controller->client();
+    return 0;
+}
+
+void ScreenOrientationController::orientationChanged(ScreenOrientationValue orientation)
+{
+    if (m_orientation == orientation)
+        return;
+
+    m_orientation = orientation;
+    for (ObserversSet::iterator it = m_observers.begin(); it != m_observers.end(); ++it)
+        (*it)->orientationChanged();
+}
+
+void ScreenOrientationController::setClientForTest(ScreenOrientationClient* client)
+{
+    m_client = client;
+    m_hasClientForTest = true;
+}
+
+void provideScreenOrientation(Page* page, ScreenOrientationClient* client)
+{
+    ScreenOrientationController::provideTo(page, ScreenOrientationController::supplementName(), ScreenOrientationController::create(client));
+}
+
+} // namespace WebCore