Use WebViewClient instead of BlinkPlatform for screen lock.

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/v8/ScriptPromise.h"
 #include "bindings/v8/ScriptPromiseResolverWithContext.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Screen.h"
+#include "core/page/Page.h"
 #include "modules/screen_orientation/LockOrientationCallback.h"
 #include "modules/screen_orientation/ScreenOrientationController.h"
-#include "public/platform/Platform.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);
 COMPILE_ASSERT_MATCHING_ENUM(WebScreenOrientationLandscapeSecondary, WebScreenOrientationLockLandscapeSecondary);
 
@@ skipping 65 matching lines @@
 }
 
 Document* ScreenOrientation::document() const
 {
     if (!m_associatedDOMWindow || !m_associatedDOMWindow->isCurrentlyDisplayedInFrame())
         return 0;
     ASSERT(m_associatedDOMWindow->document());
     return m_associatedDOMWindow->document();
 }
 
+Page* ScreenOrientation::page() const
+{
+    if (!frame())
+        return 0;
+    return frame()->page();
+}
+
 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;
 }
 
 ScreenOrientation::~ScreenOrientation()
 {
 }
 
 const AtomicString& ScreenOrientation::orientation(Screen& screen)
 {
     ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
-    if (!screenOrientation.document()) {
+    if (!screenOrientation.page()) {
         // FIXME: we should try to return a better guess, like the latest known value.
         return orientationTypeToString(blink::WebScreenOrientationPortraitPrimary);
     }
-    ScreenOrientationController& controller = ScreenOrientationController::from(*screenOrientation.document());
+    ScreenOrientationController& controller = ScreenOrientationController::from(*screenOrientation.page());

[eseidel, 2014/06/03 20:57:49]

I would just have an accessor for the controller instead and then it's a detail
as to if Page or FrameHost is used to access it.

You're right that currently Page is probably used, but it's unclear if Page is
movign to the other side of the embedder or not.  It was planned to (and
FrameHost was going to stay), but it's possible dcheng has revised that plan
since I was involved with OOPI.

[dcheng, 2014/06/03 21:02:04]

I don't think it's clear what the plan is yet so just doing this is probably the
simplest approach for now. I believe we'll have frame tree mirroring working in
a week or two, and rendering soon after that. At that point, people could try
out OOPI and see how it explodes their feature.

     return orientationTypeToString(controller.orientation());
 }
 
 ScriptPromise ScreenOrientation::lockOrientation(ScriptState* state, Screen& screen, const AtomicString& lockString)
 {
     RefPtr<ScriptPromiseResolverWithContext> resolver = ScriptPromiseResolverWithContext::create(state);
     ScriptPromise promise = resolver->promise();
 
     ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
     Document* document = screenOrientation.document();
 
-    if (!document) {
+    if (!document || !screenOrientation.page()) {
         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;
     }
 
-    blink::Platform::current()->lockOrientation(stringToOrientationLock(lockString), new LockOrientationCallback(resolver));
+    ScreenOrientationController::from(*screenOrientation.page()).lockOrientation(stringToOrientationLock(lockString), new LockOrientationCallback(resolver));
     return promise;
 }
 
 void ScreenOrientation::unlockOrientation(Screen& screen)
 {
-    blink::Platform::current()->unlockOrientation();
+    ScreenOrientation& screenOrientation = ScreenOrientation::from(screen);
+    if (!screenOrientation.page())
+        return;
+
+    ScreenOrientationController::from(*screenOrientation.page()).unlockOrientation();
 }
 
 } // namespace WebCore