arc: Support window recreation.

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 19 matching lines @@
 #include "components/user_manager/user_manager.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/base/base_window.h"
 #include "ui/display/display.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
+constexpr int kAppInstanceRequiredVersion = 3;
+constexpr char kAppInstanceConsumer[] = "ArcAppWindowLauncherController";
+
 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.
 };
 
 arc::mojom::OrientationLock GetCurrentOrientation() {
   if (!display::Display::HasInternalDisplay())
     return arc::mojom::OrientationLock::NONE;
   display::Display internal_display =
@@ skipping 104 matching lines @@
   }
 
   void Show() override {
     // TODO(khmel): support window minimizing.
   }
 
   void ShowInactive() override { NOTREACHED(); }
 
   void Hide() override { NOTREACHED(); }
 
-  void Close() override {
-    arc::mojom::AppInstance* app_instance = GetAppInstance();
-    if (!app_instance)
-      return;
-    app_instance->CloseTask(task_id_);
-  }
+  void Close() override { arc::CloseTask(task_id_); }
 
-  void Activate() override {
-    arc::mojom::AppInstance* app_instance = GetAppInstance();
-    if (!app_instance)
-      return;
-    app_instance->SetTaskActive(task_id_);
-    if (widget_)
-      widget_->Activate();
-  }
+  void Activate() override { arc::SetTaskActive(task_id_); }
 
   void Deactivate() override { NOTREACHED(); }
 
   void Maximize() override { NOTREACHED(); }
 
   void Minimize() override {
     if (widget_)
       widget_->Minimize();
   }
 
@@ skipping 17 matching lines @@
   void set_requested_orientation_lock(arc::mojom::OrientationLock lock) {
     has_requested_orientation_lock_ = true;
     requested_orientation_lock_ = lock;
   }
 
   bool has_requested_orientation_lock() const {
     return has_requested_orientation_lock_;
   }
 
  private:
-  arc::mojom::AppInstance* GetAppInstance() {
-    arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
-    arc::mojom::AppInstance* app_instance =
-        bridge_service ? bridge_service->app()->instance() : nullptr;
-    if (!app_instance) {
-      VLOG(2) << "Arc Bridge is not available.";
-      return nullptr;
-    }
-
-    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;
 
   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 22 matching lines @@
     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 {
-      UnregisterApp(app_window);
+      UnregisterApp(app_window, true);
     }
   }
 }
 
 void ArcAppWindowLauncherController::AdditionalUserAddedToSession(
     Profile* profile) {
   DCHECK(!arc::ArcAuthService::IsAllowedForProfile(profile));
 }
 
 void ArcAppWindowLauncherController::OnWindowInitialized(aura::Window* window) {
@@ skipping 12 matching lines @@
     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->GetNativeWindow() == window) {
-      OnTaskDestroyed(it.second->task_id());
-      break;
-    }
+  auto it_app_window =
+      std::find_if(task_id_to_app_window_.begin(), task_id_to_app_window_.end(),
+                   [window](const TaskIdToAppWindow::value_type& pair) {
+                     return pair.second->GetNativeWindow() == window;
+                   });
+  if (it_app_window != task_id_to_app_window_.end()) {
+    // Note, window may be recreated in some cases, so do not close controller
+    // on window destroying. Controller will be closed onTaskDestroyed event
+    // which is generated when actual task is destroyed.
+    UnregisterApp(it_app_window->second.get(), false);
+    task_id_to_app_window_.erase(it_app_window);
   }
 }
 
 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();
 }
@@ skipping 17 matching lines @@
   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())
+  TaskIdToShelfAppIdMap::iterator it = task_id_to_shelf_app_id_.find(task_id);
+  if (it == task_id_to_shelf_app_id_.end())
     return;
 
-  const TaskInfo& task_info = *it->second;
-  const std::string app_id =
-      GetShelfAppIdFromArcAppId(ArcAppListPrefs::GetAppId(
-          task_info.package_name, task_info.activity_name));
+  const std::string& app_id = it->second;
 
   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);
+  task_id_to_shelf_app_id_[task_id] = GetShelfAppIdFromArcAppId(
+      ArcAppListPrefs::GetAppId(package_name, activity_name));
 
   for (auto* window : observed_windows_)
     MayAttachContollerToWindow(window);
 }
 
 void ArcAppWindowLauncherController::OnTaskDestroyed(int task_id) {
-  task_id_to_task_info_.erase(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);
+  }
 
-  TaskIdToAppWindow::iterator it = task_id_to_app_window_.find(task_id);
-  if (it == task_id_to_app_window_.end())
+  // Check if we may close controller now, at this point we can safely remove
+  // controllers without window.
+  auto it_app_id = task_id_to_shelf_app_id_.find(task_id);
+  if (it_app_id == task_id_to_shelf_app_id_.end())
     return;
 
-  AppWindow* app_window = it->second.get();
-  UnregisterApp(app_window);
+  const std::string& app_id = it_app_id->second;
+  AppControllerMap::iterator it_controller = app_controller_map_.find(app_id);
+  if (it_controller != app_controller_map_.end()) {
+    ArcAppWindowLauncherItemController* controller = it_controller->second;
+    controller->RemoveTaskId(task_id);
+    if (!controller->window_count()) {
+      owner()->CloseLauncherItem(controller->shelf_id());
+      app_controller_map_.erase(it_controller);
+    }
+  }
 
-  task_id_to_app_window_.erase(it);
+  task_id_to_shelf_app_id_.erase(it_app_id);
 }
 
 void ArcAppWindowLauncherController::OnTaskSetActive(int32_t task_id) {
   if (observed_profile_ != owner()->GetProfile())
     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(),
@@ skipping 114 matching lines @@
     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);
+  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) {
+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());
 
   ArcAppWindowLauncherItemController* controller = it->second;
   controller->RemoveWindow(app_window);
-  if (!controller->window_count()) {
+  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();
 }
 
 void ArcAppWindowLauncherController::SetOrientationLockForAppWindow(
     AppWindow* app_window) {
   ash::WmWindow* window =
@@ skipping 15 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));
 }