Revert of 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_);
   }
 }
 
@@ skipping 45 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)
-    MayAttachContollerToWindow(window);
+    CheckForAppWindowWidget(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::MayAttachContollerToWindow(
+void ArcAppWindowLauncherController::CheckForAppWindowWidget(
     aura::Window* window) {
-  const std::string window_app_id = exo::ShellSurface::GetApplicationId(window);
-  if (window_app_id.empty())
+  const std::string app_id = exo::ShellSurface::GetApplicationId(window);
+  if (app_id.empty())
     return;
 
   int task_id = -1;
-  if (sscanf(window_app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
+  if (sscanf(app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
     return;
 
-  if (!task_id)
-    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);
+    }
 
-  // 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);
+      chrome::MultiUserWindowManager::GetInstance()->SetWindowOwner(
+          window,
+          user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId());
+      if (ash::Shell::GetInstance()
+              ->maximize_mode_controller()
+              ->IsMaximizeModeWindowManagerEnabled()) {
+        SetOrientationLockForAppWindow(app_window);
+      }
+    }
   }
-
-  // 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::WmShell::Get()
-          ->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);
 
-  for (auto* window : observed_windows_)
-    MayAttachContollerToWindow(window);
+  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);
 }
 
 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));
 }