Allow arc app to lock screen orientation in TouchView/Tablet mode

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 "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/window_state.h"
+#include "ash/common/wm_shell.h"
+#include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_util.h"
+#include "ash/shell.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/bind.h"
 #include "chrome/browser/chromeos/arc/arc_auth_service.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_window_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/exo/shell_surface.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/user_manager.h"
+#include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/base/base_window.h"
 #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.
 };
 
+blink::WebScreenOrientationLockType BlinkOrientationLockFromMojom(
+    arc::mojom::OrientationLock orientation_lock) {
+  if (orientation_lock == arc::mojom::OrientationLock::PORTRAIT) {
+    return blink::WebScreenOrientationLockPortrait;
+  } else if (orientation_lock == arc::mojom::OrientationLock::LANDSCAPE) {
+    return blink::WebScreenOrientationLockLandscape;
+  } else {
+    return blink::WebScreenOrientationLockAny;
+  }
+}
+
 }  // namespace
 
 class ArcAppWindowLauncherController::AppWindow : public ui::BaseWindow {
  public:
   AppWindow(int task_id,
             const std::string app_id,
             ArcAppWindowLauncherController* owner)
       : task_id_(task_id), app_id_(app_id), owner_(owner) {}
   ~AppWindow() {}
 
@@ skipping 102 matching lines @@
 
   void FlashFrame(bool flash) override { NOTREACHED(); }
 
   bool IsAlwaysOnTop() const override {
     NOTREACHED();
     return false;
   }
 
   void SetAlwaysOnTop(bool always_on_top) override { NOTREACHED(); }
 
+  arc::mojom::OrientationLock requested_orientation_lock() const {
+    return requested_orientation_lock_;
+  }
+
+  void set_requested_orientation_lock(arc::mojom::OrientationLock lock) {
+    has_requested_orientation_lock_ = true;
+    requested_orientation_lock_ = lock;
+  }
+
+  bool has_requested_orientation_lock() const {
+    return has_requested_orientation_lock_;
+  }
+
  private:
   arc::mojom::AppInstance* GetAppInstance() {
     arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
     arc::mojom::AppInstance* app_instance =
         bridge_service ? bridge_service->app_instance() : nullptr;
     if (!app_instance) {
       VLOG(2) << "Arc Bridge is not available.";
       return nullptr;
     }
 
     if (bridge_service->app_version() < 3) {
       VLOG(2) << "Arc Bridge has old version for apps."
               << bridge_service->app_version();
       return nullptr;
     }
     return app_instance;
   }
 
   int task_id_;
   ash::ShelfID shelf_id_ = 0;
   std::string app_id_;
   FullScreenMode fullscreen_mode_ = FullScreenMode::NOT_DEFINED;
   // Unowned pointers
   ArcAppWindowLauncherController* owner_;
   ArcAppWindowLauncherItemController* controller_ = nullptr;
   // Unowned pointer, represents host Arc window.
   views::Widget* widget_ = nullptr;
 
+  arc::mojom::OrientationLock requested_orientation_lock_ =
+      arc::mojom::OrientationLock::NONE;
+  bool has_requested_orientation_lock_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(AppWindow);
 };
 
 ArcAppWindowLauncherController::ArcAppWindowLauncherController(
     ChromeLauncherController* owner,
     ash::ShelfDelegate* shelf_delegate)
     : AppWindowLauncherController(owner), shelf_delegate_(shelf_delegate) {
   if (arc::ArcAuthService::IsAllowedForProfile(owner->GetProfile())) {
     observed_profile_ = owner->GetProfile();
     StartObserving(observed_profile_);
   }
 }
 
 ArcAppWindowLauncherController::~ArcAppWindowLauncherController() {
   if (observed_profile_)
     StopObserving(observed_profile_);
+  if (observing_shell_)
+    ash::WmShell::Get()->RemoveShellObserver(this);
 }
 
 // static
 std::string ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(
     const std::string& arc_app_id) {
   return arc_app_id == arc::kPlayStoreAppId ? ArcSupportHost::kHostAppId
                                             : arc_app_id;
 }
 
 // static
@@ skipping 65 matching lines @@
     aura::Window* window) {
   const std::string app_id = exo::ShellSurface::GetApplicationId(window);
   if (app_id.empty())
     return;
 
   int task_id = -1;
   if (sscanf(app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
     return;
 
   if (task_id) {
+    // We need to add the observer after exo started observing shell
+    // because we want to update the orientation after exo send
+    // the layout switch information.
+    if (!observing_shell_) {
+      observing_shell_ = true;
+      ash::WmShell::Get()->AddShellObserver(this);
+    }
+
     AppWindow* app_window = GetAppWindowForTask(task_id);
     if (app_window) {
       app_window->set_widget(views::Widget::GetWidgetForNativeWindow(window));
       ash::SetShelfIDForWindow(app_window->shelf_id(), window);
       if (app_window->controller())
         window->SetTitle(app_window->controller()->GetTitle());
       chrome::MultiUserWindowManager::GetInstance()->SetWindowOwner(
           window,
           user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId());
+      if (ash::WmShell::Get()
+              ->maximize_mode_controller()
+              ->IsMaximizeModeWindowManagerEnabled()) {
+        SetOrientationLockForAppWindow(app_window);
+      }
     }
   }
 }
 
 void ArcAppWindowLauncherController::OnAppReadyChanged(
     const std::string& app_id,
     bool ready) {
   if (!ready)
     OnAppRemoved(app_id);
 }
@@ skipping 78 matching lines @@
     // TODO(reveman): Figure out how to support fullscreen in interleaved
     // window mode.
     // if (new_active_app_it->second->widget()) {
     //   new_active_app_it->second->widget()->SetFullscreen(
     //       new_active_app_it->second->fullscreen_mode() ==
     //       FullScreenMode::ACTIVE);
     // }
   }
 }
 
+void ArcAppWindowLauncherController::OnTaskOrientationLockRequested(
+    int32_t task_id,
+    const arc::mojom::OrientationLock orientation_lock) {
+  // Don't save to AppInfo because this is requested in runtime.
+  TaskIdToAppWindow::iterator app_it = task_id_to_app_window_.find(task_id);
+  if (app_it == task_id_to_app_window_.end())
+    return;
+  AppWindow* app_window = app_it->second.get();
+  app_window->set_requested_orientation_lock(orientation_lock);
+
+  if (ash::WmShell::Get()
+          ->maximize_mode_controller()
+          ->IsMaximizeModeWindowManagerEnabled()) {
+    SetOrientationLockForAppWindow(app_window);
+  }
+}
+
 AppWindowLauncherItemController*
 ArcAppWindowLauncherController::ControllerForWindow(aura::Window* window) {
   AppWindow* app_window = GetAppWindowForTask(active_task_id_);
   if (app_window &&
       app_window->widget() == views::Widget::GetWidgetForNativeWindow(window)) {
     return app_window->controller();
   }
 
   for (auto& it : task_id_to_app_window_) {
     if (it.second->widget() == views::Widget::GetWidgetForNativeWindow(window))
       return it.second->controller();
   }
 
   return nullptr;
 }
 
 void ArcAppWindowLauncherController::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   OnTaskSetActive(active_task_id_);
 }
 
+void ArcAppWindowLauncherController::OnMaximizeModeStarted() {
+  for (auto& it : task_id_to_app_window_)
+    SetOrientationLockForAppWindow(it.second.get());
+}
+
+void ArcAppWindowLauncherController::OnMaximizeModeEnded() {
+  ash::ScreenOrientationController* orientation_controller =
+      ash::Shell::GetInstance()->screen_orientation_controller();
+  // Don't unlock one by one because it'll switch to next rotation.
+  orientation_controller->UnlockAll();
+}
+
 void ArcAppWindowLauncherController::StartObserving(Profile* profile) {
   aura::Env* env = aura::Env::GetInstanceDontCreate();
   if (env)
     env->AddObserver(this);
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile);
   DCHECK(prefs);
   prefs->AddObserver(this);
 }
 
 void ArcAppWindowLauncherController::StopObserving(Profile* profile) {
@@ skipping 43 matching lines @@
 
   ArcAppWindowLauncherItemController* controller = it->second;
   controller->RemoveWindow(app_window);
   if (!controller->window_count()) {
     ash::ShelfID shelf_id = app_window->shelf_id();
     owner()->CloseLauncherItem(shelf_id);
     app_controller_map_.erase(it);
   }
   app_window->ResetController();
 }
+
+void ArcAppWindowLauncherController::SetOrientationLockForAppWindow(
+    AppWindow* app_window) {
+  ash::Shell* shell = ash::Shell::GetInstance();
+  aura::Window* window = app_window->widget()->GetNativeWindow();
+  if (!window)
+    return;
+  arc::mojom::OrientationLock orientation_lock;
+  if (app_window->has_requested_orientation_lock()) {
+    orientation_lock = app_window->requested_orientation_lock();
+  } else {
+    ArcAppListPrefs* prefs = ArcAppListPrefs::Get(observed_profile_);
+    std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
+        prefs->GetApp(app_window->app_id());
+    if (!app_info)
+      return;
+    orientation_lock = app_info->orientation_lock;
+  }
+  shell->screen_orientation_controller()->LockOrientationForWindow(
+      window, BlinkOrientationLockFromMojom(orientation_lock));
+}