Implement ScreenOrientationDelegate on ChromeOS

ash/display/screen_orientation_delegate_chromeos.cc

Index: ash/display/screen_orientation_delegate_chromeos.cc
diff --git a/ash/display/screen_orientation_delegate_chromeos.cc b/ash/display/screen_orientation_delegate_chromeos.cc
new file mode 100644
index 0000000000000000000000000000000000000000..95376ec158d23fb303d589a942b9ba78da55bca0
--- /dev/null
+++ b/ash/display/screen_orientation_delegate_chromeos.cc
@@ -0,0 +1,151 @@
+// 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 "ash/display/screen_orientation_delegate_chromeos.h"
+
+#include "ash/display/display_info.h"
+#include "ash/display/display_manager.h"
+#include "ash/shell.h"
+#include "ash/wm/maximize_mode/maximize_mode_controller.h"
+#include "content/public/browser/screen_orientation_provider.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace {
+
+blink::WebScreenOrientationLockType GetDisplayNaturalOrientation() {
+  ash::DisplayManager* display_manager =
+      ash::Shell::GetInstance()->display_manager();
+  if (display_manager->HasInternalDisplay()) {
+    ash::DisplayInfo info =
+        display_manager->GetDisplayInfo(gfx::Display::InternalDisplayId());
+    gfx::Display::Rotation rotation = info.rotation();
+    gfx::Size size = info.size_in_pixel();
+    if (((rotation == gfx::Display::ROTATE_0 ||
+          rotation == gfx::Display::ROTATE_180) &&
+         size.height() >= size.width()) ||
+        ((rotation == gfx::Display::ROTATE_90 ||
+          rotation == gfx::Display::ROTATE_270) &&
+         size.height() < size.width())) {
+       return blink::WebScreenOrientationLockPortrait;
+    }
+  }
+  return blink::WebScreenOrientationLockLandscape;
+}
+
+}  // namespace
+
+namespace ash {
+
+ScreenOrientationDelegate::ScreenOrientationDelegate()
+    : natural_orientation_(GetDisplayNaturalOrientation()) {
+  content::ScreenOrientationProvider::SetDelegate(this);
+}
+
+ScreenOrientationDelegate::~ScreenOrientationDelegate() {
+  content::ScreenOrientationProvider::SetDelegate(NULL);
+}
+
+bool ScreenOrientationDelegate::FullScreenRequired(
+    content::WebContents* web_contents) {
+  return true;
+}
+
+void ScreenOrientationDelegate::Lock(
+    blink::WebScreenOrientationLockType lock_orientation) {
+  MaximizeModeController* controller =
+      Shell::GetInstance()->maximize_mode_controller();

[flackr, 2014/10/22 21:28:04]

Copying my previous comment inline to help it gain visibility:

It's confusing that the rotation lock state is managed by maximize
controller. Can we make the screen orientation delegate the rotation lock
controller and have maximize mode talk to it instead?

Maybe this makes sense as a follow-on refactoring.

[jonross, 2014/10/23 16:38:08]

I've added a TODO, as that change would need to touch more areas than just
MaximizeModeController

+  switch (lock_orientation) {
+    case blink::WebScreenOrientationLockAny:
+      controller->SetRotationLocked(false);
+      break;
+    case blink::WebScreenOrientationLockDefault:
+      NOTREACHED();
+      break;
+    case blink::WebScreenOrientationLockPortraitPrimary:
+      LockRotationToPrimaryOrientation(blink::WebScreenOrientationLockPortrait);
+      break;
+    case blink::WebScreenOrientationLockPortrait:
+      LockToRotationMatchingOrientation(lock_orientation);
+      break;
+    case blink::WebScreenOrientationLockPortraitSecondary:
+      LockRotationToSecondaryOrientation(
+          blink::WebScreenOrientationLockPortrait);
+      break;
+    case blink::WebScreenOrientationLockLandscapeSecondary:
+      LockRotationToSecondaryOrientation(
+          blink::WebScreenOrientationLockLandscape);
+      break;
+    case blink::WebScreenOrientationLockLandscapePrimary:
+      LockRotationToPrimaryOrientation(
+          blink::WebScreenOrientationLockLandscape);
+      break;
+    case blink::WebScreenOrientationLockLandscape:
+      LockToRotationMatchingOrientation(lock_orientation);
+      break;
+    case blink::WebScreenOrientationLockNatural:
+      controller->LockRotation(gfx::Display::ROTATE_0);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+bool ScreenOrientationDelegate::ScreenOrientationProviderSupported() {
+  return Shell::GetInstance()->maximize_mode_controller()->
+      IsMaximizeModeWindowManagerEnabled();
+}
+
+void ScreenOrientationDelegate::Unlock() {
+  Shell::GetInstance()->maximize_mode_controller()->SetRotationLocked(false);
+}
+
+void ScreenOrientationDelegate::LockRotationToPrimaryOrientation(
+          blink::WebScreenOrientationLockType lock_orientation) {
+  Shell::GetInstance()->maximize_mode_controller()->
+      LockRotation(natural_orientation_ == lock_orientation ?
+          gfx::Display::ROTATE_0 :
+          gfx::Display::ROTATE_90);
+}
+
+void ScreenOrientationDelegate::LockRotationToSecondaryOrientation(
+          blink::WebScreenOrientationLockType lock_orientation) {
+  Shell::GetInstance()->maximize_mode_controller()->
+      LockRotation(natural_orientation_ == lock_orientation ?
+          gfx::Display::ROTATE_180 :
+          gfx::Display::ROTATE_270);
+}
+
+void ScreenOrientationDelegate::LockToRotationMatchingOrientation(
+    blink::WebScreenOrientationLockType lock_orientation) {
+  // TODO(jonross): Update MaximizeModeController to allow rotation between
+  // two angles of an orientation (e.g. from ROTATE_0 to ROTATE_180, and from
+  // ROTATE_90 to ROTATE_270)
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+  if (!display_manager->HasInternalDisplay())
+    return;
+
+  gfx::Display::Rotation rotation = display_manager->
+    GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
+  MaximizeModeController* controller =
+      Shell::GetInstance()->maximize_mode_controller();
+  if (natural_orientation_ == lock_orientation) {
+    if (rotation == gfx::Display::ROTATE_0 ||
+        rotation == gfx::Display::ROTATE_180) {
+      controller->SetRotationLocked(true);
+    } else {
+      controller->LockRotation(gfx::Display::ROTATE_0);
+    }
+  } else {
+    if (rotation == gfx::Display::ROTATE_90 ||
+        rotation == gfx::Display::ROTATE_270) {
+      controller->SetRotationLocked(true);
+    } else {
+      controller->LockRotation(gfx::Display::ROTATE_90);
+    }
+  }
+}
+
+}  // namespace ash