arc: Show icon for the task created in background.

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/aura/wm_window_aura.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
@@ skipping 116 matching lines @@
   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_; }
 
   ArcAppWindowLauncherItemController* controller() { return controller_; }
 
-  const std::string app_id() { return app_id_; }
+  const std::string& app_id() { return app_id_; }
 
   // ui::BaseWindow:
   bool IsActive() const override {
     return widget_->IsActive() && owner_->active_task_id_ == task_id_;
   }
 
   bool IsMaximized() const override {
     NOTREACHED();
     return false;
   }
@@ skipping 120 matching lines @@
 
 void ArcAppWindowLauncherController::ActiveUserChanged(
     const std::string& user_email) {
   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();
+
+    // Make sure that we created items for all apps, not only which have a
+    // window.
+    for (const auto& it : task_id_to_shelf_app_id_)
+      AttachControllerToTask(it.second, it.first);
+
     // 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();
+
+    // Some controllers might have no windows attached, for example background
+    // task when foreground tasks is in full screen.
+    for (const auto& it : app_controller_map_)
+      owner()->CloseLauncherItem(it.second->shelf_id());
+    app_controller_map_.clear();
   }
 }
 
 void ArcAppWindowLauncherController::AdditionalUserAddedToSession(
     Profile* profile) {
   DCHECK(!arc::ArcAuthService::IsAllowedForProfile(profile));
 }
 
 void ArcAppWindowLauncherController::OnWindowInitialized(aura::Window* window) {
   // Arc windows has type WINDOW_TYPE_NORMAL.
@@ skipping 124 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));
-  task_id_to_shelf_app_id_[task_id] = GetShelfAppIdFromArcAppId(
+  const std::string shelf_app_id = GetShelfAppIdFromArcAppId(
       ArcAppListPrefs::GetAppId(package_name, activity_name));
+  task_id_to_shelf_app_id_[task_id] = shelf_app_id;
 
   // Don't create shelf icon for non-primary user.
   if (observed_profile_ != owner()->GetProfile())
     return;
 
   AttachControllerToWindowsIfNeeded();
+
+  // Some tasks can be started in background and might have no window until
+  // pushed to the front. We need its representation on the shelf to give a user
+  // control over it.
+  AttachControllerToTask(shelf_app_id, task_id);
 }
 
 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 120 matching lines @@
 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);
 }
 
+ArcAppWindowLauncherItemController*
+ArcAppWindowLauncherController::AttachControllerToTask(
+    const std::string& shelf_app_id,
+    int task_id) {
+  AppControllerMap::const_iterator it = app_controller_map_.find(shelf_app_id);
+  if (it != app_controller_map_.end()) {
+    DCHECK_EQ(it->second->app_id(), shelf_app_id);
+    it->second->AddTaskId(task_id);
+    return it->second;
+  }
+
+  ArcAppWindowLauncherItemController* controller =
+      new ArcAppWindowLauncherItemController(shelf_app_id, owner());
+  const ash::ShelfID shelf_id =
+      shelf_delegate_->GetShelfIDForAppID(shelf_app_id);
+  if (!shelf_id) {
+    owner()->CreateAppLauncherItem(controller, shelf_app_id,
+                                   ash::STATUS_RUNNING);
+  } else {
+    owner()->SetItemController(shelf_id, controller);
+    owner()->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
+  }
+  controller->AddTaskId(task_id);
+  app_controller_map_[shelf_app_id] = controller;
+  return controller;
+}
+
 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 = shelf_delegate_->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;
-  }
+  ArcAppWindowLauncherItemController* controller =
+      AttachControllerToTask(app_id, app_window->task_id());
+  DCHECK(controller);
+
+  const ash::ShelfID shelf_id = shelf_delegate_->GetShelfIDForAppID(app_id);
+  DCHECK(shelf_id);
+
   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());
@@ skipping 31 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));
 }