WIP

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/display/screen_orientation_controller_chromeos.h"
 #include "ash/public/cpp/window_properties.h"
 #include "ash/shared/app_types.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shell.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm_window.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/chromeos/arc/arc_util.h"
+#include "chrome/browser/image_decoder.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.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 "extensions/common/constants.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/display/display.h"
 #include "ui/display/manager/display_manager.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) {
   DCHECK_NE(arc::mojom::OrientationLock::CURRENT, orientation_lock);
   switch (orientation_lock) {
     case arc::mojom::OrientationLock::PORTRAIT:
       return blink::kWebScreenOrientationLockPortrait;
     case arc::mojom::OrientationLock::LANDSCAPE:
       return blink::kWebScreenOrientationLockLandscape;
     case arc::mojom::OrientationLock::PORTRAIT_PRIMARY:
       return blink::kWebScreenOrientationLockPortraitPrimary;
@@ skipping 38 matching lines @@
   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) {
+  void set_app_window(std::unique_ptr<ArcAppWindow> window) {
     app_window_ = std::move(window);
   }
 
-  AppWindow* app_window() { return app_window_.get(); }
+  ArcAppWindow* 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_;
+  std::unique_ptr<ArcAppWindow> 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:
-  AppWindow(int task_id,
-            const arc::ArcAppShelfId& app_shelf_id,
-            views::Widget* widget,
-            ArcAppWindowLauncherController* owner)
-      : task_id_(task_id),
-        app_shelf_id_(app_shelf_id),
-        widget_(widget),
-        owner_(owner) {}
-  ~AppWindow() = default;
-
-  void SetController(ArcAppWindowLauncherItemController* controller) {
-    DCHECK(!controller_ && controller);
-    controller_ = controller;
-  }
-
-  void ResetController() { controller_ = nullptr; }
-
-  void SetFullscreenMode(FullScreenMode mode) {
-    DCHECK(mode != FullScreenMode::NOT_DEFINED);
-    fullscreen_mode_ = mode;
-  }
-
-  FullScreenMode fullscreen_mode() const { return fullscreen_mode_; }
-
-  int task_id() const { return task_id_; }
-
-  const arc::ArcAppShelfId& app_shelf_id() const { return app_shelf_id_; }
-
-  const ash::ShelfID& shelf_id() const { return shelf_id_; }
-
-  void set_shelf_id(const ash::ShelfID& shelf_id) { shelf_id_ = shelf_id; }
-
-  views::Widget* widget() const { return widget_; }
-
-  ArcAppWindowLauncherItemController* controller() { return controller_; }
-
-  // ui::BaseWindow:
-  bool IsActive() const override {
-    return widget_->IsActive() && owner_->active_task_id_ == task_id_;
-  }
-
-  bool IsMaximized() const override {
-    NOTREACHED();
-    return false;
-  }
-
-  bool IsMinimized() const override {
-    NOTREACHED();
-    return false;
-  }
-
-  bool IsFullscreen() const override {
-    NOTREACHED();
-    return false;
-  }
-
-  gfx::NativeWindow GetNativeWindow() const override {
-    return widget_->GetNativeWindow();
-  }
-
-  gfx::Rect GetRestoredBounds() const override {
-    NOTREACHED();
-    return gfx::Rect();
-  }
-
-  ui::WindowShowState GetRestoredState() const override {
-    NOTREACHED();
-    return ui::SHOW_STATE_NORMAL;
-  }
-
-  gfx::Rect GetBounds() const override {
-    NOTREACHED();
-    return gfx::Rect();
-  }
-
-  void Show() override { widget_->Show(); }
-
-  void ShowInactive() override { NOTREACHED(); }
-
-  void Hide() override { NOTREACHED(); }
-
-  void Close() override { arc::CloseTask(task_id_); }
-
-  void Activate() override { widget_->Activate(); }
-
-  void Deactivate() override { NOTREACHED(); }
-
-  void Maximize() override { NOTREACHED(); }
-
-  void Minimize() override { widget_->Minimize(); }
-
-  void Restore() override { NOTREACHED(); }
-
-  void SetBounds(const gfx::Rect& bounds) override { NOTREACHED(); }
-
-  void FlashFrame(bool flash) override { NOTREACHED(); }
-
-  bool IsAlwaysOnTop() const override {
-    NOTREACHED();
-    return false;
-  }
-
-  void SetAlwaysOnTop(bool always_on_top) override { NOTREACHED(); }
-
- private:
-  const int task_id_;
-  const arc::ArcAppShelfId app_shelf_id_;
-  ash::ShelfID shelf_id_;
-  FullScreenMode fullscreen_mode_ = FullScreenMode::NOT_DEFINED;
-  // Unowned pointers
-  views::Widget* const widget_;
-  ArcAppWindowLauncherController* owner_;
-  ArcAppWindowLauncherItemController* controller_ = nullptr;
-  // Unowned pointer, represents host ARC window.
-
-  DISALLOW_COPY_AND_ASSIGN(AppWindow);
-};
-
 ArcAppWindowLauncherController::ArcAppWindowLauncherController(
     ChromeLauncherController* owner)
     : AppWindowLauncherController(owner) {
   if (arc::IsArcAllowedForProfile(owner->profile())) {
     observed_profile_ = owner->profile();
     StartObserving(observed_profile_);
   }
 }
 
 ArcAppWindowLauncherController::~ArcAppWindowLauncherController() {
@@ skipping 91 matching lines @@
     UnregisterApp(info_it->second.get());
   }
 }
 
 ArcAppWindowLauncherController::AppWindowInfo*
 ArcAppWindowLauncherController::GetAppWindowInfoForTask(int task_id) {
   const auto it = task_id_to_app_window_info_.find(task_id);
   return it == task_id_to_app_window_info_.end() ? nullptr : it->second.get();
 }
 
-ArcAppWindowLauncherController::AppWindow*
-ArcAppWindowLauncherController::GetAppWindowForTask(int task_id) {
+ArcAppWindow* ArcAppWindowLauncherController::GetAppWindowForTask(int task_id) {
   AppWindowInfo* info = GetAppWindowInfoForTask(task_id);
   return info ? info->app_window() : nullptr;
 }
 
 void ArcAppWindowLauncherController::AttachControllerToWindowsIfNeeded() {
   for (auto* window : observed_windows_)
     AttachControllerToWindowIfNeeded(window);
 }
 
 void ArcAppWindowLauncherController::AttachControllerToWindowIfNeeded(
@@ skipping 20 matching lines @@
   // Create controller if we have task info.
   AppWindowInfo* info = GetAppWindowInfoForTask(task_id);
   if (!info) {
     VLOG(1) << "Could not find AppWindowInfo for task:" << task_id;
     return;
   }
 
   views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
   DCHECK(widget);
   DCHECK(!info->app_window());
-  info->set_app_window(
-      base::MakeUnique<AppWindow>(task_id, info->app_shelf_id(), widget, this));
+  info->set_app_window(base::MakeUnique<ArcAppWindow>(
+      task_id, info->app_shelf_id(), widget, this));
   RegisterApp(info);
   DCHECK(info->app_window()->controller());
   const ash::ShelfID shelf_id(info->app_window()->shelf_id());
   window->SetProperty(ash::kShelfIDKey, new std::string(shelf_id.Serialize()));
   if (ash::Shell::Get()
           ->maximize_mode_controller()
           ->IsMaximizeModeWindowManagerEnabled()) {
     SetOrientationLockForAppWindow(info->app_window());
   }
 }
 
 void ArcAppWindowLauncherController::OnAppReadyChanged(
     const std::string& arc_app_id,
     bool ready) {
   if (!ready)
     OnAppRemoved(arc_app_id);
 }
 
 std::vector<int> ArcAppWindowLauncherController::GetTaskIdsForApp(
     const std::string& arc_app_id) const {
-  // Note, AppWindow is optional part for a task and it may be not created if
+  // Note, ArcAppWindow is optional part for a task and it may be not created if
   // another full screen Android app is currently active. Use
   // |task_id_to_app_window_info_| that keeps currently running tasks info.
   std::vector<int> task_ids;
   for (const auto& it : task_id_to_app_window_info_) {
     const AppWindowInfo* app_window_info = it.second.get();
     if (app_window_info->app_shelf_id().app_id() == arc_app_id)
       task_ids.push_back(it.first);
   }
 
   return task_ids;
@@ skipping 52 matching lines @@
 
   task_id_to_app_window_info_.erase(it);
 }
 
 void ArcAppWindowLauncherController::OnTaskSetActive(int32_t task_id) {
   if (observed_profile_ != owner()->profile()) {
     active_task_id_ = task_id;
     return;
   }
 
-  AppWindow* previous_app_window = GetAppWindowForTask(active_task_id_);
+  ArcAppWindow* previous_app_window = GetAppWindowForTask(active_task_id_);
   if (previous_app_window) {
     owner()->SetItemStatus(previous_app_window->shelf_id(),
                            ash::STATUS_RUNNING);
     previous_app_window->SetFullscreenMode(
         previous_app_window->widget() &&
                 previous_app_window->widget()->IsFullscreen()
-            ? FullScreenMode::ACTIVE
-            : FullScreenMode::NON_ACTIVE);
+            ? ArcAppWindow::FullScreenMode::ACTIVE
+            : ArcAppWindow::FullScreenMode::NON_ACTIVE);
   }
 
   active_task_id_ = task_id;
 
-  AppWindow* current_app_window = GetAppWindowForTask(task_id);
+  ArcAppWindow* current_app_window = GetAppWindowForTask(task_id);
   if (current_app_window) {
-    owner()->SetItemStatus(
-        current_app_window->shelf_id(),
-        current_app_window->widget() && current_app_window->IsActive()
-            ? ash::STATUS_ACTIVE
-            : ash::STATUS_RUNNING);
+    if (current_app_window->widget() && current_app_window->IsActive()) {
+      owner()->SetItemStatus(current_app_window->shelf_id(),
+                             ash::STATUS_ACTIVE);
+      current_app_window->controller()->SetActiveWindow(
+          current_app_window->GetNativeWindow());
+    } else {
+      owner()->SetItemStatus(current_app_window->shelf_id(),
+                             ash::STATUS_RUNNING);
+    }
     // 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);
+    //       ArcAppWindow::FullScreenMode::ACTIVE);
     // }
   }
 }
 
 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;
 
   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::Shell::Get()
           ->maximize_mode_controller()
           ->IsMaximizeModeWindowManagerEnabled()) {
-    AppWindow* app_window = info->app_window();
+    ArcAppWindow* app_window = info->app_window();
     if (app_window)
       SetOrientationLockForAppWindow(app_window);
   }
 }
 
 AppWindowLauncherItemController*
 ArcAppWindowLauncherController::ControllerForWindow(aura::Window* window) {
   if (!window)
     return nullptr;
 
-  AppWindow* app_window = GetAppWindowForTask(active_task_id_);
+  ArcAppWindow* 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_info_) {
-    AppWindow* app_window = it.second->app_window();
+    ArcAppWindow* app_window = it.second->app_window();
     if (app_window &&
         app_window->widget() ==
             views::Widget::GetWidgetForNativeWindow(window)) {
       return it.second->app_window()->controller();
     }
   }
 
   return nullptr;
 }
 
 void ArcAppWindowLauncherController::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   AppWindowLauncherController::OnWindowActivated(reason, gained_active,
                                                  lost_active);
   OnTaskSetActive(active_task_id_);
 }
 
 void ArcAppWindowLauncherController::OnMaximizeModeStarted() {
   for (auto& it : task_id_to_app_window_info_) {
-    AppWindow* app_window = it.second->app_window();
+    ArcAppWindow* app_window = it.second->app_window();
     if (app_window)
       SetOrientationLockForAppWindow(app_window);
   }
 }
 
 void ArcAppWindowLauncherController::OnMaximizeModeEnded() {
   ash::ScreenOrientationController* orientation_controller =
       ash::Shell::Get()->screen_orientation_controller();
   // Don't unlock one by one because it'll switch to next rotation.
   orientation_controller->UnlockAll();
@@ skipping 25 matching lines @@
   const arc::ArcAppShelfId& app_shelf_id = app_window_info.app_shelf_id();
   const auto it = app_shelf_group_to_controller_map_.find(app_shelf_id);
   if (it != app_shelf_group_to_controller_map_.end()) {
     DCHECK_EQ(it->second->app_id(), app_shelf_id.ToString());
     it->second->AddTaskId(task_id);
     return it->second;
   }
 
   std::unique_ptr<ArcAppWindowLauncherItemController> controller =
       base::MakeUnique<ArcAppWindowLauncherItemController>(
-          app_shelf_id.ToString());
+          app_shelf_id.ToString(), owner());
   ArcAppWindowLauncherItemController* item_controller = controller.get();
   const ash::ShelfID shelf_id(app_shelf_id.ToString());
   if (!owner()->GetItem(shelf_id)) {
     owner()->CreateAppLauncherItem(std::move(controller), ash::STATUS_RUNNING);
   } else {
     owner()->shelf_model()->SetShelfItemDelegate(shelf_id,
                                                  std::move(controller));
     owner()->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
   }
   item_controller->AddTaskId(task_id);
   app_shelf_group_to_controller_map_[app_shelf_id] = item_controller;
   return item_controller;
 }
 
 void ArcAppWindowLauncherController::RegisterApp(
     AppWindowInfo* app_window_info) {
-  AppWindow* app_window = app_window_info->app_window();
+  ArcAppWindow* app_window = app_window_info->app_window();
   ArcAppWindowLauncherItemController* controller =
       AttachControllerToTask(app_window->task_id(), *app_window_info);
   DCHECK(!controller->app_id().empty());
   const ash::ShelfID shelf_id(controller->app_id());
   DCHECK(owner()->GetItem(shelf_id));
 
   controller->AddWindow(app_window);
   owner()->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
   app_window->SetController(controller);
   app_window->set_shelf_id(shelf_id);
 }
 
 void ArcAppWindowLauncherController::UnregisterApp(
     AppWindowInfo* app_window_info) {
-  AppWindow* app_window = app_window_info->app_window();
+  ArcAppWindow* app_window = app_window_info->app_window();
   if (!app_window)
     return;
 
   ArcAppWindowLauncherItemController* controller = app_window->controller();
   if (controller)
     controller->RemoveWindow(app_window);
   app_window->ResetController();
   app_window_info->set_app_window(nullptr);
 }
 
 void ArcAppWindowLauncherController::SetOrientationLockForAppWindow(
-    AppWindow* app_window) {
+    ArcAppWindow* app_window) {
   ash::WmWindow* window =
       ash::WmWindow::Get(app_window->widget()->GetNativeWindow());
   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()) {
@@ skipping 23 matching lines @@
   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;
 }