[ScreenOrientation] De-associate device.mojom.ScreenOrientation from legacy IPC channel.

third_party/WebKit/Source/modules/screen_orientation/ScreenOrientationControllerImpl.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 "modules/screen_orientation/ScreenOrientationControllerImpl.h"
 
+#include <memory>
+#include <utility>
 #include "core/dom/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "modules/screen_orientation/ScreenOrientation.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/ScopedOrientationChangeIndicator.h"
+#include "public/platform/InterfaceProvider.h"
 #include "public/platform/WebScreenInfo.h"
-#include "public/platform/modules/screen_orientation/WebScreenOrientationClient.h"
-#include <memory>
-#include <utility>
+#include "wtf/Functional.h"
 
 namespace blink {
 
+using device::mojom::blink::ScreenOrientationLockResult;
+
 ScreenOrientationControllerImpl::~ScreenOrientationControllerImpl() = default;
 
-void ScreenOrientationControllerImpl::provideTo(
-    LocalFrame& frame,
-    WebScreenOrientationClient* client) {
+void ScreenOrientationControllerImpl::provideTo(LocalFrame& frame) {
   ScreenOrientationController::provideTo(
-      frame, new ScreenOrientationControllerImpl(frame, client));
+      frame, new ScreenOrientationControllerImpl(frame));
 }
 
 ScreenOrientationControllerImpl* ScreenOrientationControllerImpl::from(
     LocalFrame& frame) {
   return static_cast<ScreenOrientationControllerImpl*>(
       ScreenOrientationController::from(frame));
 }
 
 ScreenOrientationControllerImpl::ScreenOrientationControllerImpl(
-    LocalFrame& frame,
-    WebScreenOrientationClient* client)
+    LocalFrame& frame)
     : ScreenOrientationController(frame),
       ContextLifecycleObserver(frame.document()),
       PageVisibilityObserver(frame.page()),
-      m_client(client),
       m_dispatchEventTimer(
           TaskRunnerHelper::get(TaskType::MiscPlatformAPI, &frame),
           this,
-          &ScreenOrientationControllerImpl::dispatchEventTimerFired) {}
+          &ScreenOrientationControllerImpl::dispatchEventTimerFired) {
+  frame.interfaceProvider()->getInterface(
+      mojo::MakeRequest(&m_remoteScreenOrientation));
+}
 
 // Compute the screen orientation using the orientation angle and the screen
 // width / height.
 WebScreenOrientationType ScreenOrientationControllerImpl::computeOrientation(
     const IntRect& rect,
     uint16_t rotation) {
   // Bypass orientation detection in layout tests to get consistent results.
   // FIXME: The screen dimension should be fixed when running the layout tests
   // to avoid such issues.
   if (LayoutTestSupport::isRunningLayoutTest())
@@ skipping 30 matching lines @@
   if (orientationType == WebScreenOrientationUndefined) {
     // The embedder could not provide us with an orientation, deduce it
     // ourselves.
     orientationType = computeOrientation(chromeClient.screenInfo().rect,
                                          screenInfo.orientationAngle);
   }
   DCHECK(orientationType != WebScreenOrientationUndefined);
 
   m_orientation->setType(orientationType);
   m_orientation->setAngle(screenInfo.orientationAngle);
+
+  for (auto iter = m_waitCallbacks.begin(); iter != m_waitCallbacks.end();) {
+    if (lockMatchesCurrentOrientation(iter->second)) {
+      iter->first->onSuccess();
+      m_waitCallbacks.erase(iter);
+    } else {
+      ++iter;
+    }
+  }
 }
 
 bool ScreenOrientationControllerImpl::isActive() const {
-  return m_orientation && m_client;
+  return m_orientation && m_remoteScreenOrientation;
 }
 
 bool ScreenOrientationControllerImpl::isVisible() const {
   return page() && page()->isPageVisible();
 }
 
 bool ScreenOrientationControllerImpl::isActiveAndVisible() const {
   return isActive() && isVisible();
 }
 
@@ skipping 52 matching lines @@
 }
 
 void ScreenOrientationControllerImpl::setOrientation(
     ScreenOrientation* orientation) {
   m_orientation = orientation;
   if (m_orientation)
     updateOrientation();
   notifyAccurateListen();
 }
 
+void ScreenOrientationControllerImpl::onLockOrientationResult(
+    WebLockOrientationCallback* callback,
+    ScreenOrientationLockResult result,
+    WebScreenOrientationLockType lock) {
+  // Lock type natual has been converted to other concrete values in browser
+  // side.
+  DCHECK(lock != WebScreenOrientationLockNatural);
+  // This lock request has already been cancelled by another new lock or unlock
+  // request.
+  if (!m_pendingLockCallback || m_pendingLockCallback.get() != callback)
+    return;
+
+  switch (result) {
+    case ScreenOrientationLockResult::SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS:
+      if (lockMatchesCurrentOrientation(lock)) {
+        m_pendingLockCallback->onSuccess();
+      } else {
+        // Wait until next updateOrientation().
+        m_waitCallbacks.insert(
+            std::make_pair(std::move(m_pendingLockCallback), lock));
+      }
+      break;
+    case ScreenOrientationLockResult::
+        SCREEN_ORIENTATION_LOCK_RESULT_ERROR_NOT_AVAILABLE:
+      m_pendingLockCallback->onError(
+          blink::WebLockOrientationErrorNotAvailable);
+      break;
+    case ScreenOrientationLockResult::
+        SCREEN_ORIENTATION_LOCK_RESULT_ERROR_FULLSCREEN_REQUIRED:
+      m_pendingLockCallback->onError(
+          blink::WebLockOrientationErrorFullscreenRequired);
+      break;
+    case ScreenOrientationLockResult::
+        SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED:
+      m_pendingLockCallback->onError(blink::WebLockOrientationErrorCanceled);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+  m_pendingLockCallback = nullptr;
+}
+
+void ScreenOrientationControllerImpl::cancelPendingLock() {
+  if (!m_pendingLockCallback)
+    return;
+  m_pendingLockCallback->onError(blink::WebLockOrientationErrorCanceled);
+  m_pendingLockCallback = nullptr;
+}
+
+bool ScreenOrientationControllerImpl::lockMatchesCurrentOrientation(
+    WebScreenOrientationLockType lock) {
+  switch (lock) {
+    case WebScreenOrientationLockPortraitPrimary:
+      return m_orientation->getType() == WebScreenOrientationPortraitPrimary;
+    case WebScreenOrientationLockPortraitSecondary:
+      return m_orientation->getType() == WebScreenOrientationPortraitSecondary;
+    case WebScreenOrientationLockLandscapePrimary:
+      return m_orientation->getType() == WebScreenOrientationLandscapePrimary;
+    case WebScreenOrientationLockLandscapeSecondary:
+      return m_orientation->getType() == WebScreenOrientationLandscapeSecondary;
+    case WebScreenOrientationLockLandscape:
+      return m_orientation->getType() == WebScreenOrientationLandscapePrimary ||
+             m_orientation->getType() == WebScreenOrientationLandscapeSecondary;
+    case WebScreenOrientationLockPortrait:
+      return m_orientation->getType() == WebScreenOrientationPortraitPrimary ||
+             m_orientation->getType() == WebScreenOrientationPortraitSecondary;
+    case WebScreenOrientationLockAny:
+      return true;
+    case WebScreenOrientationLockNatural:
+    case WebScreenOrientationLockDefault:
+      NOTREACHED();
+      return false;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
 void ScreenOrientationControllerImpl::lock(
     WebScreenOrientationLockType orientation,
     std::unique_ptr<WebLockOrientationCallback> callback) {
-  // When detached, the client is no longer valid.
-  if (!m_client)
+  cancelPendingLock();
+  // When detached, the remote screen orientation is no longer valid.
+  if (!m_remoteScreenOrientation)
     return;
-  m_client->lockOrientation(orientation, std::move(callback));
-  m_activeLock = true;
+  m_remoteScreenOrientation->LockOrientation(
+      orientation,
+      convertToBaseCallback(
+          WTF::bind(&ScreenOrientationControllerImpl::onLockOrientationResult,
+                    wrapPersistent(this), WTF::unretained(callback.get()))));
+  m_pendingLockCallback = std::move(callback);
 }
 
 void ScreenOrientationControllerImpl::unlock() {
-  // When detached, the client is no longer valid.
-  if (!m_client)
+  cancelPendingLock();
+  // When detached, the remote screen orientation is no longer valid.
+  if (!m_remoteScreenOrientation)
     return;
-  m_client->unlockOrientation();
-  m_activeLock = false;
+  m_remoteScreenOrientation->UnlockOrientation();
 }
 
 bool ScreenOrientationControllerImpl::maybeHasActiveLock() const {
-  return m_activeLock;
+  return !!m_pendingLockCallback;
 }
 
 void ScreenOrientationControllerImpl::dispatchEventTimerFired(TimerBase*) {
   if (!m_orientation)
     return;
 
   ScopedOrientationChangeIndicator orientationChangeIndicator;
   m_orientation->dispatchEvent(Event::create(EventTypeNames::change));
 }
 
 void ScreenOrientationControllerImpl::contextDestroyed(ExecutionContext*) {
   if (m_startedAccurateListen) {
-    m_client->stopAccurateListen();
+    m_remoteScreenOrientation->StopAccurateListen();
     m_startedAccurateListen = false;
   }
-  m_client = nullptr;
-  m_activeLock = false;
+  m_remoteScreenOrientation = nullptr;
+  m_pendingLockCallback = nullptr;
 }
 
 void ScreenOrientationControllerImpl::notifyAccurateListen() {
   if (m_orientation && page()->isPageVisible()) {
     // Timing to start accurate listening.
     if (!m_startedAccurateListen) {
-      m_client->startAccurateListen();
+      m_remoteScreenOrientation->StartAccurateListen();
       m_startedAccurateListen = true;
     }
   } else {
     // Timing to stop accurate listening.
     if (m_startedAccurateListen) {
-      m_client->stopAccurateListen();
+      m_remoteScreenOrientation->StopAccurateListen();
       m_startedAccurateListen = false;
     }
   }
 }
 
 DEFINE_TRACE(ScreenOrientationControllerImpl) {
   visitor->trace(m_orientation);
   ContextLifecycleObserver::trace(visitor);
   Supplement<LocalFrame>::trace(visitor);
   PageVisibilityObserver::trace(visitor);
 }
 
 }  // namespace blink