[ScreenOrientation] Merge mojo interface ScreenOrientationListener into ScreenOrientation

content/browser/screen_orientation/screen_orientation_provider.cc

 // 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 "content/browser/screen_orientation/screen_orientation_provider.h"
 
 #include "base/callback_helpers.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/screen_orientation_delegate.h"
 #include "content/public/browser/web_contents.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebLockOrientationError.h"
 
+#if defined(OS_ANDROID)
+#include "content/browser/screen_orientation/screen_orientation_delegate_android.h"
+#endif
+
 namespace content {
 
 using device::mojom::ScreenOrientationLockResult;
 
 ScreenOrientationDelegate* ScreenOrientationProvider::delegate_ = nullptr;
 
 ScreenOrientationProvider::ScreenOrientationProvider(WebContents* web_contents)
     : WebContentsObserver(web_contents),
       lock_applied_(false),
       bindings_(web_contents, this) {}
 
-ScreenOrientationProvider::~ScreenOrientationProvider() = default;
+ScreenOrientationProvider::~ScreenOrientationProvider() {
+#if defined(OS_ANDROID)
+  if (accurate_listener_count_ > 0)
+    ScreenOrientationDelegateAndroid::StopAccurateListening();
+#endif
+}
 
 void ScreenOrientationProvider::LockOrientation(
     blink::WebScreenOrientationLockType orientation,
     const LockOrientationCallback& callback) {
   // Cancel any pending lock request.
   NotifyLockResult(ScreenOrientationLockResult::
                        SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
   // Record new pending lock request.
   pending_callback_ = callback;
 
@@ skipping 50 matching lines @@
                        SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
 
   if (!lock_applied_ || !delegate_)
     return;
 
   delegate_->Unlock(web_contents());
 
   lock_applied_ = false;
 }
 
+void ScreenOrientationProvider::StartAccurateListen() {
+#if defined(OS_ANDROID)
+  ++accurate_listener_count_;
+  if (accurate_listener_count_ == 1)
+    ScreenOrientationDelegateAndroid::StartAccurateListening();
+#endif
+}
+
+void ScreenOrientationProvider::StopAccurateListen() {
+#if defined(OS_ANDROID)
+  DCHECK(accurate_listener_count_ > 0);
+  --accurate_listener_count_;
+  if (accurate_listener_count_ == 0)
+    ScreenOrientationDelegateAndroid::StopAccurateListening();
+#endif
+}
+
 void ScreenOrientationProvider::OnOrientationChange() {
   if (!pending_lock_orientation_.has_value())
     return;
 
   if (LockMatchesCurrentOrientation(pending_lock_orientation_.value())) {
     DCHECK(!pending_callback_.is_null());
     NotifyLockResult(
         ScreenOrientationLockResult::SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS);
   }
 }
@@ skipping 105 matching lines @@
     case blink::WebScreenOrientationLockDefault:
       NOTREACHED();
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace content