arc: Prevent showing Arc app window for secondary user profile.

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 271 matching lines @@
 }
 
 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::OnWindowVisibilityChanged(
+void ArcAppWindowLauncherController::OnWindowPropertyChanged(
     aura::Window* window,
-    bool visible) {
-  // The application id property should be set at this time. It is important to
-  // have window->IsVisible set to true before attaching to a controller because
-  // the window is registered in multi-user manager and this manager may
-  // consider this new window as hidden for current profile. Multi-user manager
-  // uses OnWindowVisibilityChanging event to update window state.
-  if (visible && observed_profile_ == owner()->GetProfile())
-    AttachControllerToWindowIfNeeded(window);
+    const void* key,
+    intptr_t old) {
+  if (!exo::ShellSurface::IsApplicationWindowReadyPropertyKey(key))
+    return;
+
+  DCHECK(exo::ShellSurface::IsApplicationWindowReadyToShow(window));
+  if (observed_profile_ == owner()->GetProfile()) {
+    if (AttachControllerToWindowIfNeeded(window))
+      window->Show();
+  } else {
+    chrome::MultiUserWindowManager* multi_user_manager =
+        chrome::MultiUserWindowManager::GetInstance();
+    if (multi_user_manager->GetWindowOwner(window).empty()) {
+      multi_user_manager->SetWindowOwner(
+          window,
+          user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId());
+      // Now the window is registered for primary user however it is marked as
+      // hidden. Manually mark it as visible in order to get it automatically
+      // restored when user switches back to primary profile.
+      multi_user_manager->MarkWindowAsVisible(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 16 matching lines @@
   if (it == task_id_to_app_window_.end())
     return nullptr;
   return it->second.get();
 }
 
 void ArcAppWindowLauncherController::AttachControllerToWindowsIfNeeded() {
   for (auto* window : observed_windows_)
     AttachControllerToWindowIfNeeded(window);
 }
 
-void ArcAppWindowLauncherController::AttachControllerToWindowIfNeeded(
+bool ArcAppWindowLauncherController::AttachControllerToWindowIfNeeded(
     aura::Window* window) {
+  if (!exo::ShellSurface::IsApplicationWindowReadyToShow(window))
+    return false;
+
   const std::string window_app_id = exo::ShellSurface::GetApplicationId(window);
   if (window_app_id.empty())
-    return;
+    return false;
 
   int task_id = -1;
   if (sscanf(window_app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
-    return;
+    return false;
 
   if (!task_id)
-    return;
+    return false;
 
   // 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;
+    return false;
 
   // Create controller if we have task info.
   TaskIdToShelfAppIdMap::iterator it = task_id_to_shelf_app_id_.find(task_id);
   if (it == task_id_to_shelf_app_id_.end())
-    return;
+    return false;
 
   const std::string& app_id = it->second;
 
   views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
   DCHECK(widget);
   std::unique_ptr<AppWindow> app_window(
       new AppWindow(task_id, app_id, widget, this));
   RegisterApp(app_window.get());
   DCHECK(app_window->controller());
   ash::WmWindowAura::Get(window)->SetIntProperty(
       ash::WmWindowProperty::SHELF_ID, app_window->shelf_id());
   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);
+  return true;
 }
 
 void ArcAppWindowLauncherController::OnAppReadyChanged(
     const std::string& app_id,
     bool ready) {
   if (!ready)
     OnAppRemoved(app_id);
 }
 
 void ArcAppWindowLauncherController::OnAppRemoved(const std::string& app_id) {
@@ skipping 239 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));
 }