Rename apps::ShellWindow to apps::AppWindow

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 "apps/app_window.h"
+#include "apps/app_window_registry.h"
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/multi_profile_uma.h"
 #include "ash/root_window_controller.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
@@ skipping 97 matching lines @@
     } else if (browser->is_type_popup()) {
       window_type = ash::MultiProfileUMA::TELEPORT_WINDOW_POPUP;
     } else {
       window_type = ash::MultiProfileUMA::TELEPORT_WINDOW_BROWSER;
     }
   } else {
     // Unit tests might come here without a profile manager.
     if (!g_browser_process->profile_manager())
       return;
     // If it is not a browser, it is probably be a V2 application. In that case
-    // one of the ShellWindowRegistries should know about it.
-    apps::ShellWindow* shell_window = NULL;
+    // one of the AppWindowRegistry instances should know about it.
+    apps::AppWindow* app_window = NULL;
     std::vector<Profile*> profiles =
         g_browser_process->profile_manager()->GetLoadedProfiles();
     for (std::vector<Profile*>::iterator it = profiles.begin();
-         it != profiles.end() && shell_window == NULL; it++) {
-      shell_window = apps::ShellWindowRegistry::Get(
-          *it)->GetShellWindowForNativeWindow(window);
+         it != profiles.end() && app_window == NULL;
+         it++) {
+      app_window = apps::AppWindowRegistry::Get(*it)
+                       ->GetAppWindowForNativeWindow(window);
     }
-    if (shell_window) {
-      if (shell_window->window_type() ==
-              apps::ShellWindow::WINDOW_TYPE_PANEL ||
-          shell_window->window_type() ==
-              apps::ShellWindow::WINDOW_TYPE_V1_PANEL) {
+    if (app_window) {
+      if (app_window->window_type() == apps::AppWindow::WINDOW_TYPE_PANEL ||
+          app_window->window_type() == apps::AppWindow::WINDOW_TYPE_V1_PANEL) {
         window_type = ash::MultiProfileUMA::TELEPORT_WINDOW_PANEL;
       } else {
         window_type = ash::MultiProfileUMA::TELEPORT_WINDOW_V2_APP;
       }
     }
   }
   ash::MultiProfileUMA::RecordTeleportWindowType(window_type);
 }
 
 }  // namespace
@@ skipping 53 matching lines @@
   }
  private:
 
   DISALLOW_COPY_AND_ASSIGN(UserChangeActionDisabler);
 };
 
 // This class keeps track of all applications which were started for a user.
 // When an app gets created, the window will be tagged for that user. Note
 // that the destruction does not need to be tracked here since the universal
 // window observer will take care of that.
-class AppObserver : public apps::ShellWindowRegistry::Observer {
+class AppObserver : public apps::AppWindowRegistry::Observer {
  public:
   explicit AppObserver(const std::string& user_id) : user_id_(user_id) {}
   virtual ~AppObserver() {}
 
-  // ShellWindowRegistry::Observer overrides:
-  virtual void OnShellWindowAdded(apps::ShellWindow* shell_window) OVERRIDE {
-    aura::Window* window = shell_window->GetNativeWindow();
+  // AppWindowRegistry::Observer overrides:
+  virtual void OnAppWindowAdded(apps::AppWindow* app_window) OVERRIDE {
+    aura::Window* window = app_window->GetNativeWindow();
     DCHECK(window);
     MultiUserWindowManagerChromeOS::GetInstance()->SetWindowOwner(window,
                                                                   user_id_);
   }
-  virtual void OnShellWindowIconChanged(apps::ShellWindow* shell_window)
-      OVERRIDE {}
-  virtual void OnShellWindowRemoved(apps::ShellWindow* shell_window)
-      OVERRIDE {}
+  virtual void OnAppWindowIconChanged(apps::AppWindow* app_window) OVERRIDE {}
+  virtual void OnAppWindowRemoved(apps::AppWindow* app_window) OVERRIDE {}
 
  private:
   std::string user_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AppObserver);
 };
 
 MultiUserWindowManagerChromeOS::MultiUserWindowManagerChromeOS(
     const std::string& current_user_id)
     : current_user_id_(current_user_id),
@@ skipping 19 matching lines @@
 
 MultiUserWindowManagerChromeOS::~MultiUserWindowManagerChromeOS() {
   // Remove all window observers.
   WindowToEntryMap::iterator window = window_to_entry_.begin();
   while (window != window_to_entry_.end()) {
     OnWindowDestroyed(window->first);
     window = window_to_entry_.begin();
   }
 
   // Remove all app observers.
-  UserIDToShellWindowObserver::iterator app_observer_iterator =
+  UserIDToAppWindowObserver::iterator app_observer_iterator =
       user_id_to_app_observer_.begin();
   while (app_observer_iterator != user_id_to_app_observer_.end()) {
     Profile* profile = multi_user_util::GetProfileFromUserID(
         app_observer_iterator->first);
     DCHECK(profile);
-    apps::ShellWindowRegistry::Get(profile)->RemoveObserver(
-        app_observer_iterator->second);
+    apps::AppWindowRegistry::Get(profile)
+        ->RemoveObserver(app_observer_iterator->second);
     delete app_observer_iterator->second;
     user_id_to_app_observer_.erase(app_observer_iterator);
     app_observer_iterator = user_id_to_app_observer_.begin();
   }
 
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->session_state_delegate()->
         RemoveSessionStateObserver(this);
 }
 
@@ skipping 89 matching lines @@
   // Otherwise we ask the object for its desktop.
   return it->second->show_for_user();
 }
 
 void MultiUserWindowManagerChromeOS::AddUser(Profile* profile) {
   const std::string& user_id = multi_user_util::GetUserIDFromProfile(profile);
   if (user_id_to_app_observer_.find(user_id) != user_id_to_app_observer_.end())
     return;
 
   user_id_to_app_observer_[user_id] = new AppObserver(user_id);
-  apps::ShellWindowRegistry::Get(profile)->AddObserver(
-      user_id_to_app_observer_[user_id]);
+  apps::AppWindowRegistry::Get(profile)
+      ->AddObserver(user_id_to_app_observer_[user_id]);
 
   // Account all existing application windows of this user accordingly.
-  const apps::ShellWindowRegistry::ShellWindowList& shell_windows =
-      apps::ShellWindowRegistry::Get(profile)->shell_windows();
-  apps::ShellWindowRegistry::ShellWindowList::const_iterator it =
-      shell_windows.begin();
-  for (; it != shell_windows.end(); ++it)
-    user_id_to_app_observer_[user_id]->OnShellWindowAdded(*it);
+  const apps::AppWindowRegistry::AppWindowList& app_windows =
+      apps::AppWindowRegistry::Get(profile)->app_windows();
+  apps::AppWindowRegistry::AppWindowList::const_iterator it =
+      app_windows.begin();
+  for (; it != app_windows.end(); ++it)
+    user_id_to_app_observer_[user_id]->OnAppWindowAdded(*it);
 
   // Account all existing browser windows of this user accordingly.
   BrowserList* browser_list = BrowserList::GetInstance(HOST_DESKTOP_TYPE_ASH);
   BrowserList::const_iterator browser_it = browser_list->begin();
   for (; browser_it != browser_list->end(); ++browser_it) {
     if ((*browser_it)->profile()->GetOriginalProfile() == profile)
       AddBrowserWindow(*browser_it);
   }
 }
 
@@ skipping 462 matching lines @@
     window->Show();
   else
     window->Hide();
 
   // Make sure that animations have no influence on the window state after the
   // call.
   DCHECK_EQ(visible, window->IsVisible());
 }
 
 }  // namespace chrome