arc: Fix crash in multi-user env on task stop.

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 244 matching lines @@
 
 // static
 std::string ArcAppWindowLauncherController::GetArcAppIdFromShelfAppId(
     const std::string& shelf_app_id) {
   return shelf_app_id == ArcSupportHost::kHostAppId ? arc::kPlayStoreAppId
                                                     : shelf_app_id;
 }
 
 void ArcAppWindowLauncherController::ActiveUserChanged(
     const std::string& user_email) {
-  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 {
+  const std::string& primary_user_email = user_manager::UserManager::Get()
+                                              ->GetPrimaryUser()
+                                              ->GetAccountId()
+                                              .GetUserEmail();
+  if (user_email == primary_user_email) {
+    // Restore existing Arc window and create controllers for them.
+    AttachControllerToWindowsIfNeeded();
+    // Update active status.
+    OnTaskSetActive(active_task_id_);
+  } else {
+    // Remove all Arc apps and destroy its controllers. There is no mapping
+    // task id to app window because it is not safe when controller is missing.
+    for (auto& it : task_id_to_app_window_) {
+      AppWindow* app_window = it.second.get();
       UnregisterApp(app_window, true);
     }
+    task_id_to_app_window_.clear();
   }
 }
 
 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)
     return;
   observed_windows_.push_back(window);
   window->AddObserver(this);
 }
 
 void ArcAppWindowLauncherController::OnWindowVisibilityChanging(
     aura::Window* window,
     bool visible) {
   // The application id property should be set at this time.
   if (visible)
-    MayAttachContollerToWindow(window);
+    AttachControllerToWindowIfNeeded(window);
 }
 
 void ArcAppWindowLauncherController::OnWindowDestroying(aura::Window* window) {
   auto it =
       std::find(observed_windows_.begin(), observed_windows_.end(), window);
   DCHECK(it != observed_windows_.end());
   observed_windows_.erase(it);
   window->RemoveObserver(this);
 
   auto it_app_window =
@@ skipping 11 matching lines @@
 }
 
 ArcAppWindowLauncherController::AppWindow*
 ArcAppWindowLauncherController::GetAppWindowForTask(int task_id) {
   TaskIdToAppWindow::iterator it = task_id_to_app_window_.find(task_id);
   if (it == task_id_to_app_window_.end())
     return nullptr;
   return it->second.get();
 }
 
-void ArcAppWindowLauncherController::MayAttachContollerToWindow(
+void ArcAppWindowLauncherController::AttachControllerToWindowsIfNeeded() {
+  for (auto* window : observed_windows_)
+    AttachControllerToWindowIfNeeded(window);
+}
+
+void ArcAppWindowLauncherController::AttachControllerToWindowIfNeeded(
     aura::Window* window) {
   const std::string window_app_id = exo::ShellSurface::GetApplicationId(window);
   if (window_app_id.empty())
     return;
 
   int task_id = -1;
   if (sscanf(window_app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
     return;
 
   if (!task_id)
@@ skipping 63 matching lines @@
 }
 
 void ArcAppWindowLauncherController::OnTaskCreated(
     int task_id,
     const std::string& package_name,
     const std::string& activity_name) {
   DCHECK(!GetAppWindowForTask(task_id));
   task_id_to_shelf_app_id_[task_id] = GetShelfAppIdFromArcAppId(
       ArcAppListPrefs::GetAppId(package_name, activity_name));
 
-  for (auto* window : observed_windows_)
-    MayAttachContollerToWindow(window);
+  AttachControllerToWindowsIfNeeded();
 }
 
 void ArcAppWindowLauncherController::OnTaskDestroyed(int task_id) {
   auto it = task_id_to_app_window_.find(task_id);
   if (it != task_id_to_app_window_.end()) {
     AppWindow* app_window = it->second.get();
     UnregisterApp(app_window, true);
     task_id_to_app_window_.erase(it);
   }
 
@@ skipping 11 matching lines @@
     if (!controller->window_count()) {
       owner()->CloseLauncherItem(controller->shelf_id());
       app_controller_map_.erase(it_controller);
     }
   }
 
   task_id_to_shelf_app_id_.erase(it_app_id);
 }
 
 void ArcAppWindowLauncherController::OnTaskSetActive(int32_t task_id) {
-  if (observed_profile_ != owner()->GetProfile())
+  if (observed_profile_ != owner()->GetProfile()) {
+    active_task_id_ = task_id;
     return;
+  }
 
   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);
     previous_active_app_it->second->SetFullscreenMode(
         previous_active_app_it->second->widget() &&
                 previous_active_app_it->second->widget()->IsFullscreen()
             ? FullScreenMode::ACTIVE
@@ skipping 118 matching lines @@
   controller->AddWindow(app_window);
   controller->AddTaskId(app_window->task_id());
   owner()->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
   app_window->SetController(controller);
   app_window->set_shelf_id(shelf_id);
 }
 
 void ArcAppWindowLauncherController::UnregisterApp(AppWindow* app_window,
                                                    bool close_controller) {
   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());
+  CHECK(it != app_controller_map_.end());
 
   ArcAppWindowLauncherItemController* controller = it->second;
   controller->RemoveWindow(app_window);
   if (close_controller && !controller->window_count()) {
     ash::ShelfID shelf_id = app_window->shelf_id();
     owner()->CloseLauncherItem(shelf_id);
     app_controller_map_.erase(it);
   }
   app_window->ResetController();
 }
@@ skipping 19 matching lines @@
   if (orientation_lock == arc::mojom::OrientationLock::CURRENT) {
     // Resolve the orientation when it first resolved.
     orientation_lock = GetCurrentOrientation();
     app_window->set_requested_orientation_lock(orientation_lock);
   }
 
   ash::Shell* shell = ash::Shell::GetInstance();
   shell->screen_orientation_controller()->LockOrientationForWindow(
       window, BlinkOrientationLockFromMojom(orientation_lock));
 }