Resolve current orientation after applying the previous orientation request.

chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.cc

 // Copyright 2016 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 "chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.h"
 
 #include <string>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 28 matching lines @@
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 enum class FullScreenMode {
   NOT_DEFINED,  // Fullscreen mode was not defined.
   ACTIVE,       // Fullscreen is activated for an app.
   NON_ACTIVE,   // Fullscreen was not activated for an app.
 };
 
-arc::mojom::OrientationLock GetCurrentOrientation() {
-  if (!display::Display::HasInternalDisplay())
-    return arc::mojom::OrientationLock::NONE;
-  display::Display internal_display =
-      ash::Shell::GetInstance()->display_manager()->GetDisplayForId(
-          display::Display::InternalDisplayId());
-
-  // ChromeOS currently assumes that the internal panel is always
-  // landscape (ROTATE_0 == landscape).
-  switch (internal_display.rotation()) {
-    case display::Display::ROTATE_0:
-      return arc::mojom::OrientationLock::LANDSCAPE_PRIMARY;
-    case display::Display::ROTATE_90:
-      return arc::mojom::OrientationLock::PORTRAIT_PRIMARY;
-    case display::Display::ROTATE_180:
-      return arc::mojom::OrientationLock::LANDSCAPE_SECONDARY;
-    case display::Display::ROTATE_270:
-      return arc::mojom::OrientationLock::PORTRAIT_SECONDARY;
-  }
-  return arc::mojom::OrientationLock::NONE;
-}
-
 blink::WebScreenOrientationLockType BlinkOrientationLockFromMojom(
     arc::mojom::OrientationLock orientation_lock) {
   DCHECK_NE(arc::mojom::OrientationLock::CURRENT, orientation_lock);
   switch (orientation_lock) {
     case arc::mojom::OrientationLock::PORTRAIT:
       return blink::WebScreenOrientationLockPortrait;
     case arc::mojom::OrientationLock::LANDSCAPE:
       return blink::WebScreenOrientationLockLandscape;
     case arc::mojom::OrientationLock::PORTRAIT_PRIMARY:
       return blink::WebScreenOrientationLockPortraitPrimary;
     case arc::mojom::OrientationLock::LANDSCAPE_PRIMARY:
       return blink::WebScreenOrientationLockLandscapePrimary;
     case arc::mojom::OrientationLock::PORTRAIT_SECONDARY:
       return blink::WebScreenOrientationLockPortraitSecondary;
     case arc::mojom::OrientationLock::LANDSCAPE_SECONDARY:
       return blink::WebScreenOrientationLockLandscapeSecondary;
     default:
       return blink::WebScreenOrientationLockAny;
   }
 }
 
 }  // namespace
 
+using ash::ScreenOrientationController;
+
 // The information about the arc application window which has to be kept
 // even when its AppWindow is not present.
 class ArcAppWindowLauncherController::AppWindowInfo {
  public:
   explicit AppWindowInfo(const arc::ArcAppShelfId& app_shelf_id)
       : app_shelf_id_(app_shelf_id) {}
   ~AppWindowInfo() = default;
 
   const arc::ArcAppShelfId& app_shelf_id() const { return app_shelf_id_; }
 
   bool has_requested_orientation_lock() const {
     return has_requested_orientation_lock_;
   }
 
   void set_requested_orientation_lock(arc::mojom::OrientationLock lock) {
     has_requested_orientation_lock_ = true;
     requested_orientation_lock_ = lock;
   }
 
   arc::mojom::OrientationLock requested_orientation_lock() const {
     return requested_orientation_lock_;
   }
 
+  void set_lock_completion_behavior(
+      ScreenOrientationController::LockCompletionBehavior lock_behavior) {
+    lock_completion_behavior_ = lock_behavior;
+  }
+
+  ScreenOrientationController::LockCompletionBehavior lock_completion_behavior()
+      const {
+    return lock_completion_behavior_;
+  }
+
   void set_app_window(std::unique_ptr<AppWindow> window) {
     app_window_ = std::move(window);
   }
 
   AppWindow* app_window() { return app_window_.get(); }
 
  private:
   const arc::ArcAppShelfId app_shelf_id_;
   bool has_requested_orientation_lock_ = false;
+
+  // If true, the orientation should be locked to the specific
+  // orientation after the requested_orientation_lock is applied.
+  // This is meaningful only if the orientation is one of ::NONE,
+  // ::PORTRAIT or ::LANDSCAPE.
+  ScreenOrientationController::LockCompletionBehavior
+      lock_completion_behavior_ =
+          ScreenOrientationController::LockCompletionBehavior::None;
   arc::mojom::OrientationLock requested_orientation_lock_ =
       arc::mojom::OrientationLock::NONE;
   std::unique_ptr<AppWindow> app_window_;
 
   DISALLOW_COPY_AND_ASSIGN(AppWindowInfo);
 };
 
 // A ui::BaseWindow for a chromeos launcher to control ARC applications.
 class ArcAppWindowLauncherController::AppWindow : public ui::BaseWindow {
  public:
@@ skipping 412 matching lines @@
 }
 
 void ArcAppWindowLauncherController::OnTaskOrientationLockRequested(
     int32_t task_id,
     const arc::mojom::OrientationLock orientation_lock) {
   // Don't save to AppInfo in prefs because this is requested in runtime.
   AppWindowInfo* info = GetAppWindowInfoForTask(task_id);
   DCHECK(info);
   if (!info)
     return;
-  info->set_requested_orientation_lock(orientation_lock);
+
+  if (orientation_lock == arc::mojom::OrientationLock::CURRENT) {
+    info->set_lock_completion_behavior(
+        ScreenOrientationController::LockCompletionBehavior::DisableSensor);
+    if (!info->has_requested_orientation_lock()) {
+      info->set_requested_orientation_lock(arc::mojom::OrientationLock::NONE);
+    }
+  } else {
+    info->set_requested_orientation_lock(orientation_lock);
+    info->set_lock_completion_behavior(
+        ScreenOrientationController::LockCompletionBehavior::None);
+  }
 
   if (ash::WmShell::Get()
           ->maximize_mode_controller()
           ->IsMaximizeModeWindowManagerEnabled()) {
     AppWindow* app_window = info->app_window();
     if (app_window)
       SetOrientationLockForAppWindow(app_window);
   }
 }
 
@@ skipping 123 matching lines @@
 
 void ArcAppWindowLauncherController::SetOrientationLockForAppWindow(
     AppWindow* app_window) {
   ash::WmWindow* window =
       ash::WmLookup::Get()->GetWindowForWidget(app_window->widget());
   if (!window)
     return;
   AppWindowInfo* info = GetAppWindowInfoForTask(app_window->task_id());
   arc::mojom::OrientationLock orientation_lock;
 
+  ScreenOrientationController::LockCompletionBehavior lock_completion_behavior =
+      ScreenOrientationController::LockCompletionBehavior::None;
   if (info->has_requested_orientation_lock()) {
     orientation_lock = info->requested_orientation_lock();
+    lock_completion_behavior = info->lock_completion_behavior();
   } else {
     ArcAppListPrefs* prefs = ArcAppListPrefs::Get(observed_profile_);
     std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
         prefs->GetApp(info->app_shelf_id().app_id());
     if (!app_info)
       return;
     orientation_lock = app_info->orientation_lock;
-  }
-
-  if (orientation_lock == arc::mojom::OrientationLock::CURRENT) {
-    // Resolve the orientation when it first resolved.
-    orientation_lock = GetCurrentOrientation();
-    info->set_requested_orientation_lock(orientation_lock);
+    if (orientation_lock == arc::mojom::OrientationLock::CURRENT) {
+      orientation_lock = arc::mojom::OrientationLock::NONE;
+      lock_completion_behavior =
+          ScreenOrientationController::LockCompletionBehavior::DisableSensor;
+    }
   }
   ash::Shell* shell = ash::Shell::GetInstance();
   shell->screen_orientation_controller()->LockOrientationForWindow(
-      window, BlinkOrientationLockFromMojom(orientation_lock));
+      window, BlinkOrientationLockFromMojom(orientation_lock),
+      lock_completion_behavior);
 }
 
 // static
 int ArcAppWindowLauncherController::GetWindowTaskId(aura::Window* window) {
   const std::string arc_app_id = exo::ShellSurface::GetApplicationId(window);
   if (arc_app_id.empty())
     return -1;
 
   int task_id = -1;
   if (sscanf(arc_app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
     return -1;
 
   return task_id;
 }