Supports window teleports for notifications.

chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.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/multi_user_window_manager_chromeos.h"
 
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "ash/ash_switches.h"
 #include "ash/multi_profile_uma.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.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/ash/multi_user/multi_user_notification_blocker_chromeos.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.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"
+#include "ui/message_center/message_center.h"
 #include "ui/views/corewm/window_util.h"
 
 namespace {
 
 // 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 &&
@@ skipping 121 matching lines @@
 
  private:
   std::string user_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AppObserver);
 };
 
 MultiUserWindowManagerChromeOS::MultiUserWindowManagerChromeOS(
     const std::string& current_user_id)
     : current_user_id_(current_user_id),
+      notification_blocker_(new MultiUserNotificationBlockerChromeOS(
+          message_center::MessageCenter::Get(), this)),
       suppress_visibility_changes_(false) {
   // Add a session state observer to be able to monitor session changes.
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->session_state_delegate()->
         AddSessionStateObserver(this);
 
   // The BrowserListObserver would have been better to use then the old
   // notification system, but that observer fires before the window got created.
   registrar_.Add(this, NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllSources());
@@ skipping 51 matching lines @@
 
   // 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);
 
+  // Right now only |notification_blocker_| needs to know when the list of
+  // owners may change.
+  // TODO(skuhne): replace this by observer when another one needs this event.
+  notification_blocker_->UpdateWindowOwners();
+
   if (!IsWindowOnDesktopOfUser(window, current_user_id_))
     SetWindowVisibility(window, false);
 }
 
 const std::string& MultiUserWindowManagerChromeOS::GetWindowOwner(
     aura::Window* window) {
   WindowToEntryMap::iterator it = window_to_entry_.find(window);
   return it != window_to_entry_.end() ? it->second->owner()
                                       : base::EmptyString();
 }
@@ skipping 27 matching lines @@
   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_) {
     // Only show the window if it should be shown according to its state.
     if (it->second->show())
       SetWindowVisibility(window, true);
   } else {
     SetWindowVisibility(window, false);
   }
+
+  // TODO(skuhne): replace this by observer when another one needs this event.
+  notification_blocker_->UpdateWindowOwners();
 }
 
 bool MultiUserWindowManagerChromeOS::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;
 }
 
+void MultiUserWindowManagerChromeOS::GetOwnersOfVisibleWindows(
+    std::set<std::string>* user_ids) {
+  for (WindowToEntryMap::iterator it = window_to_entry_.begin();
+       it != window_to_entry_.end(); ++it) {
+    if (it->first->IsVisible())
+      user_ids->insert(it->second->owner());
+  }
+}
+
 bool MultiUserWindowManagerChromeOS::IsWindowOnDesktopOfUser(
     aura::Window* window,
     const std::string& user_id) {
   const std::string& presenting_user = GetUserPresentingWindow(window);
   return presenting_user.empty() || presenting_user == user_id;
 }
 
 const std::string& MultiUserWindowManagerChromeOS::GetUserPresentingWindow(
     aura::Window* window) {
   WindowToEntryMap::iterator it = window_to_entry_.find(window);
@@ skipping 80 matching lines @@
     ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
     if (IsWindowOnDesktopOfUser(window, user_id) &&
         !window_state->IsMinimized()) {
       aura::client::ActivationClient* client =
           aura::client::GetActivationClient(window->GetRootWindow());
       // Several unit tests come here without an activation client.
       if (client)
         client->ActivateWindow(window);
     }
   }
+
+  // This is called directly here to make sure notification_blocker will see the
+  // new window status.
+  notification_blocker_->ActiveUserChanged(user_id);
 }
 
 void MultiUserWindowManagerChromeOS::OnWindowDestroyed(aura::Window* window) {
   if (GetWindowOwner(window).empty()) {
     // This must be a window in the transient chain - remove it and its
     // children from the owner.
     RemoveTransientOwnerRecursive(window);
     return;
   }
   // Remove the state and the window observer.
   ash::wm::GetWindowState(window)->RemoveObserver(this);
   // Remove the window from the owners list.
   delete window_to_entry_[window];
   window_to_entry_.erase(window);
+  // TODO(skuhne): replace this by observer when another one needs this event.
+  notification_blocker_->UpdateWindowOwners();
 }
 
 void MultiUserWindowManagerChromeOS::OnWindowVisibilityChanging(
     aura::Window* window, bool visible) {
   // This command gets called first and immediately when show or hide gets
   // called. We remember here the desired state for restoration IF we were
   // not ourselves issuing the call.
   // Note also that using the OnWindowVisibilityChanged callback cannot be
   // used for this.
   if (suppress_visibility_changes_)
@@ skipping 205 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