Move WebScreenOrientationClient to WebFrameClient.

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/dom/Document.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Screen.h"
 #include "core/page/Page.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/PlatformScreen.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScreenOrientationClient.h"
 
 namespace WebCore {
 
 ScreenOrientationController::~ScreenOrientationController()
 {
 }
 
-void ScreenOrientationController::provideTo(Page& page, blink::WebScreenOrientationClient* client)
+void ScreenOrientationController::provideTo(LocalFrame& frame, blink::WebScreenOrientationClient* client)
 {
-    ScreenOrientationController* controller = new ScreenOrientationController(page, client);
-    WillBeHeapSupplement<Page>::provideTo(page, supplementName(), adoptPtrWillBeNoop(controller));
+    ScreenOrientationController* controller = new ScreenOrientationController(frame, client);
+    Supplement<LocalFrame>::provideTo(frame, supplementName(), adoptPtr(controller));

[sof, 2014/06/09 21:18:58]

This is not going to work, OwnPtr<>'ing something that's controlled by the
garbage collector.

I think you need to pull ScreenOrientationController off the heap (i.e., drop
NoBaseWillBeGarbageCollectedFinalized<>).

[zerny-chromium, 2014/06/10 11:43:42]

Now that LocalFrame supplements are on-heap, this should be:

WillBeHeapSupplement<LocalFrame>::provideTo(frame, supplementName(),
adoptPtrWillBeNoop(controller));

 }
 
-ScreenOrientationController& ScreenOrientationController::from(Page& page)
+ScreenOrientationController& ScreenOrientationController::from(LocalFrame& frame)
 {
-    return *static_cast<ScreenOrientationController*>(WillBeHeapSupplement<Page>::from(page, supplementName()));
+    return *static_cast<ScreenOrientationController*>(Supplement<LocalFrame>::from(frame, supplementName()));

[zerny-chromium, 2014/06/10 11:43:42]

WillBeHeapSupplement<LocalFrame>

 }
 
-ScreenOrientationController::ScreenOrientationController(Page& page, blink::WebScreenOrientationClient* client)
-    : PageLifecycleObserver(&page)
+ScreenOrientationController::ScreenOrientationController(LocalFrame& frame, blink::WebScreenOrientationClient* client)
+    : PageLifecycleObserver(frame.page())
     , m_overrideOrientation(blink::WebScreenOrientationUndefined)
     , m_client(client)
+    , m_frame(frame)
 {
 }
 
 const char* ScreenOrientationController::supplementName()
 {
     return "ScreenOrientationController";
 }
 
 // Compute the screen orientation using the orientation angle and the screen width / height.
 blink::WebScreenOrientationType ScreenOrientationController::computeOrientation(FrameView* view)
@@ skipping 20 matching lines @@
         ASSERT_NOT_REACHED();
         return blink::WebScreenOrientationPortraitPrimary;
     }
 }
 
 void ScreenOrientationController::pageVisibilityChanged()
 {
     if (page() && page()->visibilityState() == PageVisibilityStateVisible) {
         blink::WebScreenOrientationType oldOrientation = m_overrideOrientation;
         m_overrideOrientation = blink::WebScreenOrientationUndefined;
-        LocalFrame* mainFrame = page()->mainFrame();
-        if (mainFrame && oldOrientation != orientation())
-            mainFrame->sendOrientationChangeEvent();
+        if (oldOrientation != orientation())
+            m_frame.sendOrientationChangeEvent();
     } else if (m_overrideOrientation == blink::WebScreenOrientationUndefined) {
         // The page is no longer visible, store the last know screen orientation
         // so that we keep returning this orientation until the page becomes
         // visible again.
         m_overrideOrientation = orientation();
     }
 }
 
 blink::WebScreenOrientationType ScreenOrientationController::orientation() const
 {
     if (m_overrideOrientation != blink::WebScreenOrientationUndefined) {
         // The page is not visible, keep returning the last known screen orientation.
         ASSERT(!page() || page()->visibilityState() != PageVisibilityStateVisible);
         return m_overrideOrientation;
     }
 
-    LocalFrame* mainFrame = page() ? page()->mainFrame() : 0;
-    if (!mainFrame)
-        return blink::WebScreenOrientationPortraitPrimary;
-    blink::WebScreenOrientationType orientationType = screenOrientationType(mainFrame->view());
+    blink::WebScreenOrientationType orientationType = screenOrientationType(m_frame.view());
     if (orientationType == blink::WebScreenOrientationUndefined) {
         // The embedder could not provide us with an orientation, deduce it ourselves.
-        orientationType = computeOrientation(mainFrame->view());
+        orientationType = computeOrientation(m_frame.view());
     }
     ASSERT(orientationType != blink::WebScreenOrientationUndefined);
     return orientationType;
 }
 
 void ScreenOrientationController::lockOrientation(blink::WebScreenOrientationLockType orientation, blink::WebLockOrientationCallback* callback)
 {
     if (!m_client) {
         // FIXME: temporary until the content layer gets updated.
         blink::Platform::current()->lockOrientation(orientation, callback);
         return;
     }
 
     m_client->lockOrientation(orientation, callback);
 }
 
 void ScreenOrientationController::unlockOrientation()
 {
     if (!m_client) {
         // FIXME: temporary until the content layer gets updated.
         blink::Platform::current()->unlockOrientation();
         return;
     }
 
     m_client->unlockOrientation();
 }
 
 } // namespace WebCore