Absolute Device Orientation API: blink implementation.

third_party/WebKit/Source/modules/device_orientation/DeviceOrientationAbsoluteController.cpp

Index: third_party/WebKit/Source/modules/device_orientation/DeviceOrientationAbsoluteController.cpp
diff --git a/third_party/WebKit/Source/modules/device_orientation/DeviceOrientationAbsoluteController.cpp b/third_party/WebKit/Source/modules/device_orientation/DeviceOrientationAbsoluteController.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..41812872cf56a25bafbb7fc7fca909911f4d3f0d
--- /dev/null
+++ b/third_party/WebKit/Source/modules/device_orientation/DeviceOrientationAbsoluteController.cpp
@@ -0,0 +1,128 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.

[Rick Byers, 2015/10/21 18:54:46]

This file seems like a fairly complete copy/paste of
DeviceOrientationController.cpp.  Can't we share the logic somehow?  Eg. make
DeviceOrientationController take a boolean parameter indicating whether it's
absolute or not and then keep two instances with the two different values?

[timvolodine, 2015/10/22 15:06:28]

right, ok I've refactored the code a bit to reuse the common bits. I ended up
subclassing DeviceOrientationController and templating the
DeviceOrientationDispatcher. Introducing a 'boolean' switch in controller seems
a bit hard since it uses ::from(Document) as you already mentioned. Subclassing
seems to resolve this problem by overriding the few different methods.

+// 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/device_orientation/DeviceOrientationAbsoluteController.h"
+
+#include "core/dom/Document.h"
+#include "core/frame/Settings.h"
+#include "modules/EventModules.h"
+#include "modules/device_orientation/DeviceOrientationAbsoluteDispatcher.h"
+#include "modules/device_orientation/DeviceOrientationData.h"
+#include "modules/device_orientation/DeviceOrientationEvent.h"
+#include "public/platform/Platform.h"
+
+namespace blink {
+
+DeviceOrientationAbsoluteController::DeviceOrientationAbsoluteController(Document& document)
+    : DeviceSingleWindowEventController(document)
+{
+}
+
+DeviceOrientationAbsoluteController::~DeviceOrientationAbsoluteController()
+{
+#if !ENABLE(OILPAN)
+    stopUpdating();
+#endif
+}
+
+void DeviceOrientationAbsoluteController::didUpdateData()
+{
+    if (m_overrideOrientationData)
+        return;
+    dispatchDeviceEvent(lastEvent());
+}
+
+const char* DeviceOrientationAbsoluteController::supplementName()
+{
+    return "DeviceOrientationAbsoluteController";
+}
+
+DeviceOrientationAbsoluteController& DeviceOrientationAbsoluteController::from(Document& document)
+{
+    DeviceOrientationAbsoluteController* controller = static_cast<DeviceOrientationAbsoluteController*>(WillBeHeapSupplement<Document>::from(document, supplementName()));
+    if (!controller) {
+        controller = new DeviceOrientationAbsoluteController(document);
+        WillBeHeapSupplement<Document>::provideTo(document, supplementName(), adoptPtrWillBeNoop(controller));
+    }
+    return *controller;
+}
+
+void DeviceOrientationAbsoluteController::didAddEventListener(LocalDOMWindow* window, const AtomicString& eventType)
+{
+    if (eventType != eventTypeName())
+        return;
+
+    if (document().frame()) {
+        String errorMessage;
+        if (!document().isSecureContext(errorMessage) && document().frame()->settings()->strictPowerfulFeatureRestrictions())
+            return;
+        // FIXME: add user counters as in DeviceOrientationController.
+    }
+
+    // FIXME: add rappor url logging as in DeviceOrientationController.
+
+    DeviceSingleWindowEventController::didAddEventListener(window, eventType);
+}
+
+DeviceOrientationData* DeviceOrientationAbsoluteController::lastData() const
+{
+    return m_overrideOrientationData ? m_overrideOrientationData.get() : DeviceOrientationAbsoluteDispatcher::instance().latestDeviceOrientationData();
+}
+
+bool DeviceOrientationAbsoluteController::hasLastData()
+{
+    return lastData();
+}
+
+void DeviceOrientationAbsoluteController::registerWithDispatcher()
+{
+    DeviceOrientationAbsoluteDispatcher::instance().addController(this);
+}
+
+void DeviceOrientationAbsoluteController::unregisterWithDispatcher()
+{
+    DeviceOrientationAbsoluteDispatcher::instance().removeController(this);
+}
+
+PassRefPtrWillBeRawPtr<Event> DeviceOrientationAbsoluteController::lastEvent() const
+{
+    return DeviceOrientationEvent::create(eventTypeName(), lastData());
+}
+
+bool DeviceOrientationAbsoluteController::isNullEvent(Event* event) const
+{
+    DeviceOrientationEvent* orientationEvent = toDeviceOrientationEvent(event);
+    return !orientationEvent->orientation()->canProvideEventData();
+}
+
+const AtomicString& DeviceOrientationAbsoluteController::eventTypeName() const
+{
+    return EventTypeNames::deviceorientationabsolute;
+}
+
+void DeviceOrientationAbsoluteController::setOverride(DeviceOrientationData* deviceOrientationData)
+{
+    ASSERT(deviceOrientationData);
+    m_overrideOrientationData = deviceOrientationData;
+    dispatchDeviceEvent(lastEvent());
+}
+
+void DeviceOrientationAbsoluteController::clearOverride()
+{
+    if (!m_overrideOrientationData)
+        return;
+    m_overrideOrientationData.clear();
+    if (lastData())
+        didUpdateData();
+}
+
+DEFINE_TRACE(DeviceOrientationAbsoluteController)
+{
+    visitor->trace(m_overrideOrientationData);
+    DeviceSingleWindowEventController::trace(visitor);
+    WillBeHeapSupplement<Document>::trace(visitor);
+}
+
+} // namespace blink