Fixing drag and drop visibility issues of tabs on a visiting desktop

chrome/browser/ui/ash/multi_user_window_manager.cc

 // Copyright 2013 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/multi_user_window_manager.h"
 
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "ash/ash_switches.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_state.h"
 #include "base/auto_reset.h"
+#include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_types.h"
+#include "ui/events/event.h"
 
 namespace {
 chrome::MultiUserWindowManager* g_instance = NULL;
+
+
+// Checks if a given event is a user event.
+bool IsUserEvent(ui::Event* e) {
+  if (e) {
+    ui::EventType type = e->type();
+    if (type != ui::ET_CANCEL_MODE &&
+        type != ui::ET_UMA_DATA &&
+        type != ui::ET_UNKNOWN)
+      return true;
+  }
+  return false;
+}
+
+// Test if we are currently processing a user event which might lead to a
+// browser / app creation.
+bool IsProcessingUserEvent() {
+  // When there is a nested message loop (e.g. active menu or drag and drop
+  // operation) - we are in a nested loop and can ignore this.
+  // Note: Unit tests might not have a message loop.
+  base::MessageLoop* message_loop = base::MessageLoop::current();
+  if (message_loop && message_loop->is_running() && message_loop->IsNested())
+    return false;
+
+  // TODO(skuhne): "Open link in new window" will come here after the menu got
+  // closed, executing the command from the nested menu loop. However at that
+  // time there is no active event processed. A solution for that need to be
+  // found past M-32. A global event handler filter (pre and post) might fix
+  // that problem in conjunction with a depth counter - but - for the menu
+  // execution we come here after the loop was finished (so it's not nested
+  // anymore) and the root window should therefore still have the event which
+  // lead to the menu invocation, but it is not. By fixing that problem this
+  // would "magically work".
+  ash::Shell::RootWindowList root_window_list = ash::Shell::GetAllRootWindows();
+  for (ash::Shell::RootWindowList::iterator it = root_window_list.begin();
+       it != root_window_list.end();
+       ++it) {
+    if (IsUserEvent((*it)->current_event()))
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 namespace chrome {
 
 // Caching the current multi profile mode since the detection which mode is
 // used is quite expensive.
 chrome::MultiUserWindowManager::MultiProfileMode
     chrome::MultiUserWindowManager::multi_user_mode_ =
         chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_UNINITIALIZED;
 
@@ skipping 115 matching lines @@
 void MultiUserWindowManager::SetWindowOwner(aura::Window* window,
                                             const std::string& user_id) {
   // Make sure the window is valid and there was no owner yet.
   DCHECK(window);
   DCHECK(!user_id.empty());
   if (GetWindowOwner(window) == user_id)
     return;
   DCHECK(GetWindowOwner(window).empty());
   window_to_entry_[window] = new WindowEntry(user_id);
 
+  // Remember the initial visibility of the window.
+  window_to_entry_[window]->set_show(window->IsVisible());
+
   // Set the window and the state observer.
   window->AddObserver(this);
   ash::wm::GetWindowState(window)->AddObserver(this);
 
+  // Check if this window was created due to a user interaction. If it was,
+  // transfer it to the current user.
+  if (IsProcessingUserEvent())
+    window_to_entry_[window]->set_show_for_user(current_user_id_);
+
   // Add all transient children to our set of windows. Note that the function
   // will add the children but not the owner to the transient children map.
   AddTransientOwnerRecursive(window, window);
 
-  if (user_id != current_user_id_)
+  if (!IsWindowOnDesktopOfUser(window, current_user_id_))
     SetWindowVisibility(window, false);
 }
 
 const std::string& MultiUserWindowManager::GetWindowOwner(
     aura::Window* window) {
   WindowToEntryMap::iterator it = window_to_entry_.find(window);
   return it != window_to_entry_.end() ? it->second->owner() : EmptyString();
 }
 
 void MultiUserWindowManager::ShowWindowForUser(aura::Window* window,
                                                const std::string& user_id) {
   // If there is either no owner, or the owner is the current user, no action
   // is required.
   const std::string& owner = GetWindowOwner(window);
   if (owner.empty() ||
       (owner == user_id && IsWindowOnDesktopOfUser(window, user_id)))
     return;
 
   // Check that we are not trying to transfer ownership of a minimized window.
   if (user_id != owner && ash::wm::GetWindowState(window)->IsMinimized())
     return;
 
   WindowToEntryMap::iterator it = window_to_entry_.find(window);
   it->second->set_show_for_user(user_id);
 
   // Show the window if the added user is the current one.
-  if (user_id == current_user_id_)
-    SetWindowVisibility(window, true);
-  else
+  if (user_id == current_user_id_) {
+    // Only show the window if it should be shown according to its state.
+    if (it->second->show())
+      SetWindowVisibility(window, true);
+  } else {
     SetWindowVisibility(window, false);
+  }
 }
 
 bool MultiUserWindowManager::AreWindowsSharedAmongUsers() {
   WindowToEntryMap::iterator it = window_to_entry_.begin();
   for (; it != window_to_entry_.end(); ++it) {
     if (it->second->owner() != it->second->show_for_user())
       return true;
   }
   return false;
 }
@@ skipping 265 matching lines @@
 
 void MultiUserWindowManager::SetWindowVisibility(
     aura::Window* window, bool visible) {
   if (window->IsVisible() == visible)
     return;
 
   // To avoid that these commands are recorded as any other commands, we are
   // suppressing any window entry changes while this is going on.
   base::AutoReset<bool> suppressor(&suppress_visibility_changes_, true);
 
-  if (visible)
+  if (visible) {
     ShowWithTransientChildrenRecursive(window);
-  else
+  } else {
+    if (window->HasFocus())
+      window->Blur();
     window->Hide();
+  }
 }
 
 void MultiUserWindowManager::ShowWithTransientChildrenRecursive(
     aura::Window* window) {
   aura::Window::Windows::const_iterator it =
       window->transient_children().begin();
   for (; it !=  window->transient_children().end(); ++it)
     ShowWithTransientChildrenRecursive(*it);
 
   // We show all children which were not explicitly hidden.
@@ skipping 67 matching lines @@
     // To prevent these commands from being recorded as any other commands, we
     // are suppressing any window entry changes while this is going on.
     // Instead of calling SetWindowVisible, only show gets called here since all
     // dependents have been shown previously already.
     base::AutoReset<bool> suppressor(&suppress_visibility_changes_, true);
     window->Show();
   }
 }
 
 }  // namespace chrome