Make Screen Orientation use Platform Events in order to handle polling.

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 "modules/screen_orientation/ScreenOrientationController.h"
 
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/page/Page.h"
 #include "modules/screen_orientation/ScreenOrientation.h"
+#include "modules/screen_orientation/ScreenOrientationDispatcher.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/PlatformScreen.h"
 #include "public/platform/WebScreenOrientationClient.h"
 
 namespace blink {
 
 ScreenOrientationController::~ScreenOrientationController()
 {
 }
 
@@ skipping 10 matching lines @@
     ScreenOrientationController* controller = new ScreenOrientationController(frame, client);
     WillBeHeapSupplement<LocalFrame>::provideTo(frame, supplementName(), adoptPtrWillBeNoop(controller));
 }
 
 ScreenOrientationController* ScreenOrientationController::from(LocalFrame& frame)
 {
     return static_cast<ScreenOrientationController*>(WillBeHeapSupplement<LocalFrame>::from(frame, supplementName()));
 }
 
 ScreenOrientationController::ScreenOrientationController(LocalFrame& frame, blink::WebScreenOrientationClient* client)
-    : PageLifecycleObserver(frame.page())
+    : PlatformEventController(frame.page())
     , m_client(client)
     , m_frame(frame)
     , m_dispatchEventTimer(this, &ScreenOrientationController::dispatchEventTimerFired)
 {
 }
 
 const char* ScreenOrientationController::supplementName()
 {
     return "ScreenOrientationController";
 }
@@ skipping 35 matching lines @@
         orientationType = computeOrientation(m_frame.view());
     }
     ASSERT(orientationType != blink::WebScreenOrientationUndefined);
 
     m_orientation->setType(orientationType);
     m_orientation->setAngle(screenOrientationAngle(m_frame.view()));
 }
 
 void ScreenOrientationController::pageVisibilityChanged()
 {
+    notifyDispatcher();
+
     if (!m_orientation || !page() || page()->visibilityState() != PageVisibilityStateVisible)
         return;
 
     // The orientation type and angle are tied in a way that if the angle has
     // changed, the type must have changed.
     unsigned short currentAngle = screenOrientationAngle(m_frame.view());
 
     // FIXME: sendOrientationChangeEvent() currently send an event all the
     // children of the frame, so it should only be called on the frame on
     // top of the tree. We would need the embedder to call
@@ skipping 31 matching lines @@
         if (controller)
             controller->notifyOrientationChanged();
     }
 }
 
 void ScreenOrientationController::setOrientation(ScreenOrientation* orientation)
 {
     m_orientation = orientation;
     if (m_orientation)
         updateOrientation();
+    notifyDispatcher();
 }
 
 void ScreenOrientationController::lock(blink::WebScreenOrientationLockType orientation, blink::WebLockOrientationCallback* callback)
 {
     ASSERT(m_client);
     m_client->lockOrientation(orientation, callback);
 }
 
 void ScreenOrientationController::unlock()
 {
     ASSERT(m_client);
     m_client->unlockOrientation();
 }
 
 const LocalFrame& ScreenOrientationController::frame() const
 {
     return m_frame;
 }
 
 void ScreenOrientationController::dispatchEventTimerFired(Timer<ScreenOrientationController>*)
 {
     if (!m_orientation)
         return;
     m_orientation->dispatchEvent(Event::create(EventTypeNames::change));
 }
 
+void ScreenOrientationController::didUpdateData()
+{
+    // Do nothing.
+}
+
+void ScreenOrientationController::registerWithDispatcher()
+{
+    ScreenOrientationDispatcher::instance().addController(this);
+}
+
+void ScreenOrientationController::unregisterWithDispatcher()
+{
+    ScreenOrientationDispatcher::instance().removeController(this);
+}
+
+bool ScreenOrientationController::hasLastData()
+{
+    return true;
+}
+
+void ScreenOrientationController::notifyDispatcher()
+{
+    if (m_orientation && page()->visibilityState() == PageVisibilityStateVisible)
+        startUpdating();
+    else
+        stopUpdating();
+}
+
 void ScreenOrientationController::trace(Visitor* visitor)
 {
     visitor->trace(m_orientation);
     WillBeHeapSupplement<LocalFrame>::trace(visitor);
 }
 
 } // namespace blink