Show/Hide the Arc App windows and corresponding shelf items when switching between desktops.

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/window_state.h"
 #include "ash/shelf/shelf_util.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 "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.
 };
 
 std::string GetShelfAppId(const std::string& app_id) {
   return app_id == arc::kPlayStoreAppId ? ArcSupportHost::kHostAppId : app_id;
 }
 }  // namespace
 
 class ArcAppWindowLauncherController::AppWindow : public ui::BaseWindow {
  public:
-  AppWindow(int task_id, ArcAppWindowLauncherController* owner)
-      : task_id_(task_id), owner_(owner) {}
+  AppWindow(int task_id,
+            const std::string app_id,
+            ArcAppWindowLauncherController* owner)
+      : task_id_(task_id), app_id_(app_id), owner_(owner) {}
   ~AppWindow() {}
 
   void SetController(ArcAppWindowLauncherItemController* controller) {
     DCHECK(!controller_ && controller);
     controller_ = controller;
   }
 
   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_; }
 
   ash::ShelfID shelf_id() const { return shelf_id_; }
 
   void set_shelf_id(ash::ShelfID shelf_id) { shelf_id_ = shelf_id; }
 
   views::Widget* widget() const { return widget_; }
 
   void set_widget(views::Widget* widget) { widget_ = widget; }
 
   ArcAppWindowLauncherItemController* controller() { return controller_; }
 
+  const std::string app_id() { return app_id_; }
+
   // ui::BaseWindow:
   bool IsActive() const override {
     return widget_ && widget_->IsActive() &&
            owner_->active_task_id_ == task_id_;
   }
 
   bool IsMaximized() const override {
     NOTREACHED();
     return false;
   }
@@ skipping 83 matching lines @@
     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;
 
   DISALLOW_COPY_AND_ASSIGN(AppWindow);
 };
 
 ArcAppWindowLauncherController::ArcAppWindowLauncherController(
     ChromeLauncherController* owner)
     : AppWindowLauncherController(owner) {
   if (arc::ArcAuthService::IsAllowedForProfile(owner->profile())) {
     observed_profile_ = owner->profile();
     StartObserving(observed_profile_);
   }
 }
 
 ArcAppWindowLauncherController::~ArcAppWindowLauncherController() {
   if (observed_profile_)
     StopObserving(observed_profile_);
 }
 
 void ArcAppWindowLauncherController::ActiveUserChanged(
     const std::string& user_email) {
-  // TODO(xdai): Traverse the Arc App list to show / hide the apps one by one
-  // if there are Arc Apps running.
+  for (auto& it : task_id_to_app_window_) {
+    AppWindow* app_window = it.second.get();
+    if (user_email ==
+        user_manager::UserManager::Get()
+            ->GetPrimaryUser()
+            ->GetAccountId()
+            .GetUserEmail()) {
+      RegisterApp(app_window);
+    } else {
+      UnRegisterApp(app_window);
+    }
+  }
 }
 
 void ArcAppWindowLauncherController::AdditionalUserAddedToSession(
     Profile* profile) {
   DCHECK(!arc::ArcAuthService::IsAllowedForProfile(profile));
 }
 
 void ArcAppWindowLauncherController::OnWindowInitialized(aura::Window* window) {
   // Arc windows has type WINDOW_TYPE_NORMAL.
   if (window->type() != ui::wm::WINDOW_TYPE_NORMAL)
@@ skipping 36 matching lines @@
   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) {
     AppWindow* app_window = GetAppWindowForTask(task_id);
-    if (app_window)
+    if (app_window) {
       app_window->set_widget(views::Widget::GetWidgetForNativeWindow(window));
+      chrome::MultiUserWindowManager::GetInstance()->SetWindowOwner(
+          window,
+          user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId());
+    }
   }
 }
 
 void ArcAppWindowLauncherController::OnAppReadyChanged(
     const std::string& app_id,
     bool ready) {
   if (!ready)
     OnAppRemoved(app_id);
 }
 
@@ skipping 15 matching lines @@
 
   DCHECK(app_controller_map_.find(app_id) == app_controller_map_.end());
 }
 
 void ArcAppWindowLauncherController::OnTaskCreated(
     int task_id,
     const std::string& package_name,
     const std::string& activity_name) {
   DCHECK(!GetAppWindowForTask(task_id));
 
-  std::unique_ptr<AppWindow> app_window(new AppWindow(task_id, this));
-
   const std::string app_id =
       GetShelfAppId(ArcAppListPrefs::GetAppId(package_name, activity_name));
 
-  ArcAppWindowLauncherItemController* controller;
-  AppControllerMap::iterator it = app_controller_map_.find(app_id);
-  ash::ShelfID shelf_id = 0;
-  if (it != app_controller_map_.end()) {
-    controller = it->second;
-    DCHECK_EQ(controller->app_id(), app_id);
-    shelf_id = controller->shelf_id();
-  } else {
-    controller = new ArcAppWindowLauncherItemController(app_id, owner());
-    shelf_id = owner()->GetShelfIDForAppID(app_id);
-    if (shelf_id == 0) {
-      // Map Play Store shelf icon to Arc Support host, to share one entry.
-      shelf_id = owner()->CreateAppLauncherItem(controller, app_id,
-                                                ash::STATUS_RUNNING);
-    } else {
-      owner()->SetItemController(shelf_id, controller);
-    }
-    app_controller_map_[app_id] = controller;
-  }
-  controller->AddWindow(app_window.get());
-  owner()->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
-  app_window->SetController(controller);
-  app_window->set_shelf_id(shelf_id);
+  std::unique_ptr<AppWindow> app_window(new AppWindow(task_id, app_id, this));
+  RegisterApp(app_window.get());
 
   task_id_to_app_window_[task_id] = std::move(app_window);
 
   for (auto window : observed_windows_)
     CheckForAppWindowWidget(window);
 }
 
 void ArcAppWindowLauncherController::OnTaskDestroyed(int task_id) {
   TaskIdToAppWindow::iterator it = task_id_to_app_window_.find(task_id);
   if (it == task_id_to_app_window_.end())
     return;
 
   AppWindow* app_window = it->second.get();
-  ArcAppWindowLauncherItemController* controller = app_window->controller();
-  DCHECK(controller);
-  const std::string app_id = controller->app_id();
-  controller->RemoveWindow(app_window);
-  if (!controller->window_count()) {
-    ash::ShelfID shelf_id = app_window->shelf_id();
-    DCHECK(shelf_id);
-    owner()->CloseLauncherItem(shelf_id);
-    AppControllerMap::iterator it2 = app_controller_map_.find(app_id);
-    DCHECK(it2 != app_controller_map_.end());
-    app_controller_map_.erase(it2);
-  }
+  UnRegisterApp(app_window);
 
   task_id_to_app_window_.erase(it);
 }
 
 void ArcAppWindowLauncherController::OnTaskSetActive(int32_t task_id) {
   TaskIdToAppWindow::iterator previous_active_app_it =
       task_id_to_app_window_.find(active_task_id_);
   if (previous_active_app_it != task_id_to_app_window_.end()) {
     owner()->SetItemStatus(previous_active_app_it->second->shelf_id(),
                            ash::STATUS_RUNNING);
@@ skipping 37 matching lines @@
     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) {

[reveman, 2016/06/03 21:51:47]

can you explain what the changes to this function are needed for?

[xdai1, 2016/06/03 22:14:46]

This change is necessary because otherwise OnTaskSetActive() will be called
whenever there is a change on window activation. OnTaskSetActive() tries to
update the arc shelf item's status, however, in multi-profile scenario, the
corresponding ArcAppWindowLauncherItemController might have been deleted in
UnRegisterApp(), which will then cause a browser crash.

[reveman, 2016/06/03 22:49:35]

Ok, I think that might be a bit easier to understand if we instead handle that
in OnTaskSetActive. And maybe use
ArcAppWindowLauncherController::ControllerForWindow to make it even more clear?

-  OnTaskSetActive(active_task_id_);
+  AppWindow* app_window = GetAppWindowForTask(active_task_id_);
+  if (app_window &&
+      ((gained_active &&
+        app_window->widget() ==
+            views::Widget::GetWidgetForNativeWindow(gained_active)) ||
+       (lost_active &&
+        app_window->widget() ==
+            views::Widget::GetWidgetForNativeWindow(lost_active)))) {
+    OnTaskSetActive(active_task_id_);
+  }
 }
 
 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) {
   for (auto window : observed_windows_)
     window->RemoveObserver(this);
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile);
   prefs->RemoveObserver(this);
   aura::Env* env = aura::Env::GetInstanceDontCreate();
   if (env)
     env->RemoveObserver(this);
 }
+
+void ArcAppWindowLauncherController::RegisterApp(AppWindow* app_window) {
+  const std::string app_id = app_window->app_id();
+  DCHECK(!app_id.empty());
+
+  ArcAppWindowLauncherItemController* controller;
+  AppControllerMap::iterator it = app_controller_map_.find(app_id);
+  ash::ShelfID shelf_id = 0;
+  if (it != app_controller_map_.end()) {
+    controller = it->second;
+    DCHECK_EQ(controller->app_id(), app_id);
+    shelf_id = controller->shelf_id();
+  } else {
+    controller = new ArcAppWindowLauncherItemController(app_id, owner());
+    shelf_id = owner()->GetShelfIDForAppID(app_id);
+    if (shelf_id == 0) {
+      // Map Play Store shelf icon to Arc Support host, to share one entry.
+      shelf_id = owner()->CreateAppLauncherItem(controller, app_id,
+                                                ash::STATUS_RUNNING);
+    } else {
+      owner()->SetItemController(shelf_id, controller);
+    }
+    app_controller_map_[app_id] = controller;
+  }
+  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(AppWindow* app_window) {
+  const std::string app_id = app_window->app_id();
+  DCHECK(!app_id.empty());
+  AppControllerMap::iterator it = app_controller_map_.find(app_id);
+  DCHECK(it != app_controller_map_.end());
+
+  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);
+  }
+}