[ScreenOrientation] Merge mojo interface ScreenOrientationListener into ScreenOrientation

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 "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 "modules/screen_orientation/ScreenOrientationDispatcher.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/ScopedOrientationChangeIndicator.h"
 #include "public/platform/WebScreenInfo.h"
 #include "public/platform/modules/screen_orientation/WebScreenOrientationClient.h"
 #include <memory>
 #include <utility>
 
 namespace blink {
 
 ScreenOrientationControllerImpl::~ScreenOrientationControllerImpl() = default;
 
 void ScreenOrientationControllerImpl::provideTo(
     LocalFrame& frame,
     WebScreenOrientationClient* client) {
   ScreenOrientationController::provideTo(
       frame, new ScreenOrientationControllerImpl(frame, client));
 }
 
 ScreenOrientationControllerImpl* ScreenOrientationControllerImpl::from(
     LocalFrame& frame) {
   return static_cast<ScreenOrientationControllerImpl*>(
       ScreenOrientationController::from(frame));
 }
 
 ScreenOrientationControllerImpl::ScreenOrientationControllerImpl(
     LocalFrame& frame,
     WebScreenOrientationClient* client)
     : ScreenOrientationController(frame),
       ContextLifecycleObserver(frame.document()),
-      PlatformEventController(&frame),
+      PageVisibilityObserver(frame.page()),
       m_client(client),
       m_dispatchEventTimer(
           TaskRunnerHelper::get(TaskType::MiscPlatformAPI, &frame),
           this,
           &ScreenOrientationControllerImpl::dispatchEventTimerFired) {}
 
 // Compute the screen orientation using the orientation angle and the screen
 // width / height.
 WebScreenOrientationType ScreenOrientationControllerImpl::computeOrientation(
     const IntRect& rect,
@@ skipping 50 matching lines @@
 
 bool ScreenOrientationControllerImpl::isVisible() const {
   return page() && page()->isPageVisible();
 }
 
 bool ScreenOrientationControllerImpl::isActiveAndVisible() const {
   return isActive() && isVisible();
 }
 
 void ScreenOrientationControllerImpl::pageVisibilityChanged() {
-  notifyDispatcher();
+  notifyAccurateListen();
 
   if (!isActiveAndVisible())
     return;
 
   DCHECK(frame());
   DCHECK(frame()->host());
 
   // The orientation type and angle are tied in a way that if the angle has
   // changed, the type must have changed.
   unsigned short currentAngle =
@@ skipping 37 matching lines @@
       controller->notifyOrientationChanged();
     }
   }
 }
 
 void ScreenOrientationControllerImpl::setOrientation(
     ScreenOrientation* orientation) {
   m_orientation = orientation;
   if (m_orientation)
     updateOrientation();
-  notifyDispatcher();
+  notifyAccurateListen();
 }
 
 void ScreenOrientationControllerImpl::lock(
     WebScreenOrientationLockType orientation,
     std::unique_ptr<WebLockOrientationCallback> callback) {
   // When detached, the client is no longer valid.
   if (!m_client)
     return;
   m_client->lockOrientation(orientation, std::move(callback));
   m_activeLock = true;
@@ skipping 12 matching lines @@
 }
 
 void ScreenOrientationControllerImpl::dispatchEventTimerFired(TimerBase*) {
   if (!m_orientation)
     return;
 
   ScopedOrientationChangeIndicator orientationChangeIndicator;
   m_orientation->dispatchEvent(Event::create(EventTypeNames::change));
 }
 
-void ScreenOrientationControllerImpl::didUpdateData() {
-  // Do nothing.
-}
-
-void ScreenOrientationControllerImpl::registerWithDispatcher() {
-  ScreenOrientationDispatcher::instance().addController(this);
-}
-
-void ScreenOrientationControllerImpl::unregisterWithDispatcher() {
-  ScreenOrientationDispatcher::instance().removeController(this);
-}
-
-bool ScreenOrientationControllerImpl::hasLastData() {
-  return true;
-}
-
 void ScreenOrientationControllerImpl::contextDestroyed(ExecutionContext*) {
-  stopUpdating();
+  if (m_startedAccurateListen) {
+    m_client->stopAccurateListen();
+    m_startedAccurateListen = false;
+  }
   m_client = nullptr;
   m_activeLock = false;
 }
 
-void ScreenOrientationControllerImpl::notifyDispatcher() {
-  if (m_orientation && page()->isPageVisible())
-    startUpdating();
-  else
-    stopUpdating();
+void ScreenOrientationControllerImpl::notifyAccurateListen() {
+  if (m_orientation && page()->isPageVisible()) {
+    // Timing to start accurate listening.
+    if (!m_startedAccurateListen) {
+      m_client->startAccurateListen();
+      m_startedAccurateListen = true;
+    }
+  } else {
+    // Timing to stop accurate listening.
+    if (m_startedAccurateListen) {
+      m_client->stopAccurateListen();
+      m_startedAccurateListen = false;
+    }
+  }
 }
 
 DEFINE_TRACE(ScreenOrientationControllerImpl) {
   visitor->trace(m_orientation);
   ContextLifecycleObserver::trace(visitor);
   Supplement<LocalFrame>::trace(visitor);
-  PlatformEventController::trace(visitor);
+  PageVisibilityObserver::trace(visitor);
 }
 
 }  // namespace blink