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,
+    const ScreenOrientationLockCallback& on_result_callback,
     WebContents* web_contents)
     : ScreenOrientationProvider(),
       WebContentsObserver(web_contents),
-      dispatcher_(dispatcher),
+      on_result_callback_(on_result_callback),
       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::LockOrientation(
-    int request_id,
-    blink::WebScreenOrientationLockType lock_orientation) {
+    ScreenOrientationLockType lock_type) {
+  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);
+    on_result_callback_.Run(
+        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);
+      on_result_callback_.Run(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);
+    on_result_callback_.Run(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_)) {
+    on_result_callback_.Run(SCREEN_ORIENTATION_LOCK_RESULT_SUCCESS);
+    pending_lock_orientation_ = blink::WebScreenOrientationLockDefault;
   }
 }
 
 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,
+    const ScreenOrientationLockCallback& on_result_callback,
     WebContents* web_contents) {
-  return new ScreenOrientationProviderAndroid(dispatcher, web_contents);
+  return new ScreenOrientationProviderAndroid(on_result_callback, web_contents);
 }
 
 } // namespace content