Create Mojo service for locking/unlocking screen orientation.

content/browser/screen_orientation/screen_orientation_provider_android.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_android.h"
 
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/screen_orientation_utils.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
-#include "content/public/browser/screen_orientation_dispatcher_host.h"
 #include "jni/ScreenOrientationProvider_jni.h"
 #include "third_party/WebKit/public/platform/WebLockOrientationError.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 
 namespace content {
 
-ScreenOrientationProviderAndroid::LockInformation::LockInformation(
-    int request_id, blink::WebScreenOrientationLockType lock)
-    : request_id(request_id), lock(lock) {}
-
 ScreenOrientationProviderAndroid::ScreenOrientationProviderAndroid(
-    ScreenOrientationDispatcherHost* dispatcher,
     WebContents* web_contents)
     : ScreenOrientationProvider(),
       WebContentsObserver(web_contents),
-      dispatcher_(dispatcher),
       lock_applied_(false),
-      pending_lock_(NULL) {
+      pending_lock_orientation_(blink::WebScreenOrientationLockDefault) {
 }
 
 ScreenOrientationProviderAndroid::~ScreenOrientationProviderAndroid() {
-  if (pending_lock_)
-    delete pending_lock_;
 }
 
 WebContentsImpl* ScreenOrientationProviderAndroid::web_contents_impl() {
   return static_cast<WebContentsImpl*>(web_contents());
 }
 
 // static
 bool ScreenOrientationProviderAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
+void ScreenOrientationProviderAndroid::NotifyLockResult(
+    ScreenOrientationLockResult result) {
+  if (on_result_callback_.is_null())
+    return;
+  on_result_callback_.Run(result);
+  pending_lock_orientation_ = blink::WebScreenOrientationLockDefault;
+  on_result_callback_ = ScreenOrientationLockCallback();
+}
+
 void ScreenOrientationProviderAndroid::LockOrientation(
-    int request_id,
-    blink::WebScreenOrientationLockType lock_orientation) {
+    ScreenOrientationLockType lock_type,
+    const ScreenOrientationLockCallback& callback) {
+  // Cancel any pending request.
+  NotifyLockResult(SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
+  on_result_callback_ = callback;
+
+  blink::WebScreenOrientationLockType lock_orientation =
+      ScreenOrientationLockTypeToWebScreenOrientationLockType(lock_type);
   ContentViewCoreImpl* cvc =
       ContentViewCoreImpl::FromWebContents(web_contents());
   bool fullscreen_required = cvc ? cvc->IsFullscreenRequiredForOrientationLock()
                                  : true;
 
   if (fullscreen_required &&
       !web_contents_impl()->IsFullscreenForCurrentTab()) {
-    dispatcher_->NotifyLockError(
-        request_id,
-        blink::WebLockOrientationErrorFullScreenRequired);
+    NotifyLockResult(SCREEN_ORIENTATION_LOCK_RESULT_ERROR_FULLSCREEN_REQUIRED);
     return;
   }
 
   if (lock_orientation == blink::WebScreenOrientationLockNatural) {
     lock_orientation = GetNaturalLockType();
     if (lock_orientation == blink::WebScreenOrientationLockDefault) {
       // We are in a broken state, let's pretend we got canceled.
-      dispatcher_->NotifyLockError(request_id,
-                                   blink::WebLockOrientationErrorCanceled);
+      NotifyLockResult(SCREEN_ORIENTATION_LOCK_RESULT_ERROR_CANCELED);
       return;
     }
   }
 
   lock_applied_ = true;
   Java_ScreenOrientationProvider_lockOrientation(
       base::android::AttachCurrentThread(), lock_orientation);
 
-  // If two calls happen close to each other, Android will ignore the first.
-  if (pending_lock_) {
-    delete pending_lock_;
-    pending_lock_ = NULL;
-  }
-
   // If the orientation we are locking to matches the current orientation, we
   // should succeed immediately.
   if (LockMatchesCurrentOrientation(lock_orientation)) {
-    dispatcher_->NotifyLockSuccess(request_id);
+    NotifyLockResult(SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS);
     return;
   }
 
-  pending_lock_ = new LockInformation(request_id, lock_orientation);
+  pending_lock_orientation_ = lock_orientation;
 }
 
 void ScreenOrientationProviderAndroid::UnlockOrientation() {
   if (!lock_applied_)
     return;
 
   Java_ScreenOrientationProvider_unlockOrientation(
       base::android::AttachCurrentThread());
   lock_applied_ = false;
 }
 
 void ScreenOrientationProviderAndroid::OnOrientationChange() {
-  if (!pending_lock_)
+  if (pending_lock_orientation_ == blink::WebScreenOrientationLockDefault)
     return;
 
-  if (LockMatchesCurrentOrientation(pending_lock_->lock)) {
-    dispatcher_->NotifyLockSuccess(pending_lock_->request_id);
-    delete pending_lock_;
-    pending_lock_ = NULL;
+  if (LockMatchesCurrentOrientation(pending_lock_orientation_)) {

[qsr, 2014/09/23 08:22:59]

I don't understand exactly why we need this. If we can receive this message for
other reason than the request, then we can randomly get the right orientation,
so this might be true for another reason than the request. In the end, given the
way concurrent request can happen, I'm wondering why we don't just respond with
a success just after sending the request to the system. Given that a lock can be
overridden by a concurrent frame the ms after it succeeds, trying to return an
error for this case seems a lot of work for no benefit. What am I missing?

 Mounir, do you remember why we do it this way?

+    DCHECK(!on_result_callback_.is_null());
+    NotifyLockResult(SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS);
   }
 }
 
 void ScreenOrientationProviderAndroid::DidToggleFullscreenModeForTab(
     bool entered_fullscreen) {
   if (!lock_applied_)
     return;
 
   // If fullscreen is not required in order to lock orientation, don't unlock
   // when fullscreen state changes.
@@ skipping 90 matching lines @@
 }
 
 // static
 void ScreenOrientationProviderAndroid::StopAccurateListening() {
   Java_ScreenOrientationProvider_stopAccurateListening(
       base::android::AttachCurrentThread());
 }
 
 // static
 ScreenOrientationProvider* ScreenOrientationProvider::Create(
-    ScreenOrientationDispatcherHost* dispatcher,
     WebContents* web_contents) {
-  return new ScreenOrientationProviderAndroid(dispatcher, web_contents);
+  return new ScreenOrientationProviderAndroid(web_contents);
 }
 
 } // namespace content