arc: Fix crash on Arc window close.

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/wm/window_state.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/display_manager.h"
@@ skipping 228 matching lines @@
   // 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);
 };
 
+struct ArcAppWindowLauncherController::TaskInfo {
+  TaskInfo(const std::string& package_name, const std::string& activity_name)
+      : package_name(package_name), activity_name(activity_name) {}
+  ~TaskInfo() {}
+
+  std::string package_name;
+  std::string activity_name;
+};
+
 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);
+
+  // Special for M53 branch. Due different deletion order of the shell

[khmel, 2016/08/19 21:00:12]

patch for M53

+  // and shelf launcher controllers we have to care about pending Arc
+  // items because we cannot observe window detroying events anymore.
+  // This is the reason of crashing unit_tests: ArcOrientationLock
+  for (auto& it : task_id_to_app_window_)
+    UnregisterApp(it.second.get());
 }
 
 // static
 std::string ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(
     const std::string& arc_app_id) {
   return arc_app_id == arc::kPlayStoreAppId ? ArcSupportHost::kHostAppId
                                             : arc_app_id;
 }
 
 // static
@@ skipping 30 matching lines @@
     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)
-    CheckForAppWindowWidget(window);
+    MayAttachContollerToWindow(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);
 
   for (auto& it : task_id_to_app_window_) {
     if (it.second->widget() == views::Widget::GetWidgetForNativeWindow(window))
       it.second->set_widget(nullptr);
   }
 }
 
 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::CheckForAppWindowWidget(
+void ArcAppWindowLauncherController::MayAttachContollerToWindow(
     aura::Window* window) {
-  const std::string app_id = exo::ShellSurface::GetApplicationId(window);
-  if (app_id.empty())
+  const std::string window_app_id = exo::ShellSurface::GetApplicationId(window);
+  if (window_app_id.empty())
     return;
 
   int task_id = -1;
-  if (sscanf(app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
+  if (sscanf(window_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);
-    }
+  if (!task_id)
+    return;
 
-    AppWindow* app_window = GetAppWindowForTask(task_id);
-    if (app_window) {
-      app_window->set_widget(views::Widget::GetWidgetForNativeWindow(window));
-      ash::SetShelfIDForWindow(app_window->shelf_id(), window);
-      chrome::MultiUserWindowManager::GetInstance()->SetWindowOwner(
-          window,
-          user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId());
-      if (ash::Shell::GetInstance()
-              ->maximize_mode_controller()
-              ->IsMaximizeModeWindowManagerEnabled()) {
-        SetOrientationLockForAppWindow(app_window);
-      }
-    }
+  // 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);
   }
+
+  // Check if we have controller for this task.
+  if (GetAppWindowForTask(task_id))
+    return;
+
+  // Create controller if we have task info.
+  TaskIdToTaskInfoMap::iterator it = task_id_to_task_info_.find(task_id);
+  if (it == task_id_to_task_info_.end())
+    return;
+
+  const TaskInfo& task_info = *it->second;
+  const std::string app_id =
+      GetShelfAppIdFromArcAppId(ArcAppListPrefs::GetAppId(
+          task_info.package_name, task_info.activity_name));
+
+  std::unique_ptr<AppWindow> app_window(new AppWindow(task_id, app_id, this));
+  app_window->set_widget(views::Widget::GetWidgetForNativeWindow(window));
+  RegisterApp(app_window.get());
+  DCHECK(app_window->controller());
+  ash::SetShelfIDForWindow(app_window->shelf_id(), window);
+  chrome::MultiUserWindowManager::GetInstance()->SetWindowOwner(
+      window,
+      user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId());
+  if (ash::Shell::GetInstance()
+          ->maximize_mode_controller()
+          ->IsMaximizeModeWindowManagerEnabled()) {
+    SetOrientationLockForAppWindow(app_window.get());
+  }
+  task_id_to_app_window_[task_id] = std::move(app_window);
+
+  // TaskInfo is no longer needed. Discard it.
+  task_id_to_task_info_.erase(task_id);
 }
 
 void ArcAppWindowLauncherController::OnAppReadyChanged(
     const std::string& app_id,
     bool ready) {
   if (!ready)
     OnAppRemoved(app_id);
 }
 
 void ArcAppWindowLauncherController::OnAppRemoved(const std::string& app_id) {
@@ skipping 15 matching lines @@
     OnTaskDestroyed(task_id);
 
   DCHECK(app_controller_map_.find(shelf_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<TaskInfo> task_info(
+      new TaskInfo(package_name, activity_name));
+  task_id_to_task_info_[task_id] = std::move(task_info);
 
-  const std::string app_id = GetShelfAppIdFromArcAppId(
-      ArcAppListPrefs::GetAppId(package_name, activity_name));
-
-  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);
+  for (auto* window : observed_windows_)
+    MayAttachContollerToWindow(window);
 }
 
 void ArcAppWindowLauncherController::OnTaskDestroyed(int task_id) {
+  task_id_to_task_info_.erase(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();
   UnregisterApp(app_window);
 
   task_id_to_app_window_.erase(it);
 }
 
@@ skipping 170 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);
   }
 
   shell->screen_orientation_controller()->LockOrientationForWindow(
       window, BlinkOrientationLockFromMojom(orientation_lock));
 }