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

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) {}
+    : WebContentsObserver(web_contents), lock_applied_(false) {}
 
 ScreenOrientationProvider::~ScreenOrientationProvider() {
 #if defined(OS_ANDROID)
   if (accurate_listener_count_ > 0)
     ScreenOrientationDelegateAndroid::StopAccurateListening();
 #endif
 }
 
+// static
+void ScreenOrientationProvider::SetDelegate(
+    ScreenOrientationDelegate* delegate) {
+  delegate_ = delegate;
+}
+
+// static
+void ScreenOrientationProvider::BindRequest(
+    RenderFrameHost* render_frame_host,
+    device::mojom::ScreenOrientationRequest request) {
+  WebContents* web_contents =
+      WebContents::FromRenderFrameHost(render_frame_host);
+  DCHECK(web_contents);
+
+  static_cast<WebContentsImpl*>(web_contents)
+      ->GetScreenOrientationProvider()
+      ->AddBinding(std::move(request));
+}
+
+void ScreenOrientationProvider::AddBinding(
+    device::mojom::ScreenOrientationRequest request) {
+  bindings_.AddBinding(this, std::move(request));
+}
+
 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;
+  pending_lock_orientation_ = orientation;
 
   if (!delegate_ || !delegate_->ScreenOrientationProviderSupported()) {
     NotifyLockResult(ScreenOrientationLockResult::
                          SCREEN_ORIENTATION_LOCK_RESULT_ERROR_NOT_AVAILABLE);
     return;
   }
 
   if (delegate_->FullScreenRequired(web_contents())) {
     RenderViewHostImpl* rvhi =
         static_cast<RenderViewHostImpl*>(web_contents()->GetRenderViewHost());
     if (!rvhi) {
       NotifyLockResult(ScreenOrientationLockResult::
                            SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
       return;
     }
     if (!static_cast<WebContentsImpl*>(web_contents())
              ->IsFullscreenForCurrentTab()) {
       NotifyLockResult(
           ScreenOrientationLockResult::
               SCREEN_ORIENTATION_LOCK_RESULT_ERROR_FULLSCREEN_REQUIRED);
       return;
     }
   }
 
   if (orientation == blink::WebScreenOrientationLockNatural) {
     orientation = GetNaturalLockType();
+    pending_lock_orientation_ = orientation;
     if (orientation == blink::WebScreenOrientationLockDefault) {
       // We are in a broken state, let's pretend we got canceled.
       NotifyLockResult(ScreenOrientationLockResult::
                            SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
       return;
     }
   }
 
   lock_applied_ = true;
   delegate_->Lock(web_contents(), orientation);
 
   // If the orientation we are locking to matches the current orientation, we
   // should succeed immediately.
   if (LockMatchesCurrentOrientation(orientation)) {
     NotifyLockResult(
         ScreenOrientationLockResult::SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS);
     return;
   }
-
-  pending_lock_orientation_ = orientation;
 }
 
 void ScreenOrientationProvider::UnlockOrientation() {
   // Cancel any pending lock request.
   NotifyLockResult(ScreenOrientationLockResult::
                        SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
 
   if (!lock_applied_ || !delegate_)
     return;
 
@@ skipping 25 matching lines @@
 
   if (LockMatchesCurrentOrientation(pending_lock_orientation_.value())) {
     DCHECK(!pending_callback_.is_null());
     NotifyLockResult(
         ScreenOrientationLockResult::SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS);
   }
 }
 
 void ScreenOrientationProvider::NotifyLockResult(
     ScreenOrientationLockResult result) {
-  if (!pending_callback_.is_null())
-    base::ResetAndReturn(&pending_callback_).Run(result);
-
-  pending_lock_orientation_.reset();
-}
-
-void ScreenOrientationProvider::SetDelegate(
-    ScreenOrientationDelegate* delegate) {
-  delegate_ = delegate;
+  if (!pending_callback_.is_null()) {
+    DCHECK(pending_lock_orientation_.has_value());
+    base::ResetAndReturn(&pending_callback_)
+        .Run(result, pending_lock_orientation_.value());
+    pending_lock_orientation_.reset();
+  } else {
+    DCHECK(!pending_lock_orientation_.has_value());
+  }
 }
 
 void ScreenOrientationProvider::DidToggleFullscreenModeForTab(
     bool entered_fullscreen,
     bool will_cause_resize) {
   if (!lock_applied_ || !delegate_)
     return;
 
   // If fullscreen is not required in order to lock orientation, don't unlock
   // when fullscreen state changes.
@@ skipping 83 matching lines @@
     case blink::WebScreenOrientationLockDefault:
       NOTREACHED();
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 }  // namespace content