[screen-orientation] Update implementation to match recent spec changes.

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 "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
-#include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
-#include "core/frame/Screen.h"
+#include "modules/EventTargetModules.h"
 #include "modules/screen_orientation/LockOrientationCallback.h"
 #include "modules/screen_orientation/ScreenOrientationController.h"
 #include "public/platform/WebScreenOrientationType.h"
 
 // This code assumes that WebScreenOrientationType values are included in WebScreenOrientationLockType.
 #define COMPILE_ASSERT_MATCHING_ENUM(enum1, enum2) \
     COMPILE_ASSERT(static_cast<unsigned>(blink::enum1) == static_cast<unsigned>(blink::enum2), mismatching_types)
 COMPILE_ASSERT_MATCHING_ENUM(WebScreenOrientationPortraitPrimary, WebScreenOrientationLockPortraitPrimary);
 COMPILE_ASSERT_MATCHING_ENUM(WebScreenOrientationPortraitSecondary, WebScreenOrientationLockPortraitSecondary);
 COMPILE_ASSERT_MATCHING_ENUM(WebScreenOrientationLandscapePrimary, WebScreenOrientationLockLandscapePrimary);
@@ skipping 51 matching lines @@
     ScreenOrientationInfo* orientationMap = orientationsMap(length);
     for (unsigned i = 0; i < length; ++i) {
         if (orientationMap[i].name == orientationLockString)
             return static_cast<blink::WebScreenOrientationLockType>(orientationMap[i].orientation);
     }
 
     ASSERT_NOT_REACHED();
     return blink::WebScreenOrientationLockDefault;
 }
 
-ScreenOrientation::ScreenOrientation(Screen& screen)
-    : DOMWindowProperty(screen.frame())
+// static
+ScreenOrientation* ScreenOrientation::create(ScreenOrientationController* controller, ExecutionContext* executionContext)
 {
+    ScreenOrientation* orientation = adoptRefCountedGarbageCollectedWillBeNoop(new ScreenOrientation(controller, executionContext));
+    orientation->suspendIfNeeded();
+    controller->setOrientation(orientation);
+
+    return orientation;
 }
 
-const char* ScreenOrientation::supplementName()
+ScreenOrientation::ScreenOrientation(ScreenOrientationController* controller, ExecutionContext* executionContext)
+    : ActiveDOMObject(executionContext)
+    , m_controller(controller)
+    , m_type(blink::WebScreenOrientationUndefined)
+    , m_angle(0)
 {
-    return "ScreenOrientation";
-}
-
-Document* ScreenOrientation::document() const
-{
-    if (!m_associatedDOMWindow || !m_associatedDOMWindow->isCurrentlyDisplayedInFrame())
-        return 0;
-    ASSERT(m_associatedDOMWindow->document());
-    return m_associatedDOMWindow->document();
-}
-
-ScreenOrientation& ScreenOrientation::from(Screen& screen)
-{
-    ScreenOrientation* supplement = static_cast<ScreenOrientation*>(WillBeHeapSupplement<Screen>::from(screen, supplementName()));
-    if (!supplement) {
-        supplement = new ScreenOrientation(screen);
-        provideTo(screen, supplementName(), adoptPtrWillBeNoop(supplement));
-    }
-    return *supplement;
+    ScriptWrappable::init(this);
 }
 
 ScreenOrientation::~ScreenOrientation()
 {
+    m_controller->setOrientation(0);
 }
 
-const AtomicString& ScreenOrientation::orientation(Screen& screen)
+const WTF::AtomicString& ScreenOrientation::interfaceName() const
 {
-    ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
-    if (!screenOrientation.frame()) {
-        // FIXME: we should try to return a better guess, like the latest known value.
-        return orientationTypeToString(blink::WebScreenOrientationPortraitPrimary);
-    }
-    ScreenOrientationController& controller = ScreenOrientationController::from(*screenOrientation.frame());
-    return orientationTypeToString(controller.orientation());
+    return EventTargetNames::ScreenOrientation;
 }
 
-ScriptPromise ScreenOrientation::lockOrientation(ScriptState* state, Screen& screen, const AtomicString& lockString)
+ExecutionContext* ScreenOrientation::executionContext() const
+{
+    return ActiveDOMObject::executionContext();
+}
+
+String ScreenOrientation::type() const
+{
+    return orientationTypeToString(m_type);
+}
+
+unsigned short ScreenOrientation::angle() const
+{
+    return m_angle;
+}
+
+void ScreenOrientation::setType(blink::WebScreenOrientationType type)
+{
+    m_type = type;
+}
+
+void ScreenOrientation::setAngle(unsigned short angle)
+{
+    m_angle = angle;
+}
+
+ScriptPromise ScreenOrientation::lock(ScriptState* state, const AtomicString& lockString)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(state);
     ScriptPromise promise = resolver->promise();
 
-    ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
-    Document* document = screenOrientation.document();
+    Document* document = m_controller->frame().document();
 
-    if (!document || !screenOrientation.frame()) {
+    if (!document) {
         RefPtrWillBeRawPtr<DOMException> exception = DOMException::create(InvalidStateError, "The object is no longer associated to a document.");
         resolver->reject(exception);
         return promise;
     }
 
     if (document->isSandboxed(SandboxOrientationLock)) {
         RefPtrWillBeRawPtr<DOMException> exception = DOMException::create(SecurityError, "The document is sandboxed and lacks the 'allow-orientation-lock' flag.");
         resolver->reject(exception);
         return promise;
     }
 
-    ScreenOrientationController::from(*screenOrientation.frame()).lockOrientation(stringToOrientationLock(lockString), new LockOrientationCallback(resolver));
+    m_controller->lock(stringToOrientationLock(lockString), new LockOrientationCallback(resolver));
     return promise;
 }
 
-void ScreenOrientation::unlockOrientation(Screen& screen)
+void ScreenOrientation::unlock()
 {
-    ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
-    if (!screenOrientation.frame())
-        return;
+    m_controller->unlock();
+}
 
-    ScreenOrientationController::from(*screenOrientation.frame()).unlockOrientation();
+bool ScreenOrientation::hasPendingActivity() const
+{
+    return hasEventListeners();
+}

[abarth-chromium, 2014/07/07 17:29:33]

You don't need this code because this object is kept alive by virtue of being
stored at window.screen.orientation.

Worse, this line of code will cause a memory leak.  If script adds an event
listener to this object, it will have pending activity forever and never be
garbage collected.

[mlamouri (slow - plz ping), 2014/07/08 14:07:59]

Done.

+
+void ScreenOrientation::trace(Visitor* visitor)
+{
+    EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace WebCore