Rename apps::ShellWindow to apps::AppWindow

apps/app_shim/extension_app_shim_handler_mac.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 "apps/app_shim/extension_app_shim_handler_mac.h"
 
 #include "apps/app_lifetime_monitor_factory.h"
 #include "apps/app_shim/app_shim_host_manager_mac.h"
 #include "apps/app_shim/app_shim_messages.h"
+#include "apps/app_window.h"
+#include "apps/app_window_registry.h"
 #include "apps/launcher.h"
-#include "apps/shell_window.h"
-#include "apps/shell_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
 #include "chrome/browser/ui/extensions/extension_enable_flow_delegate.h"
 #include "chrome/browser/ui/web_applications/web_app_ui.h"
 #include "chrome/browser/ui/webui/ntp/core_app_launcher_handler.h"
 #include "chrome/browser/web_applications/web_app_mac.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/extension_registry.h"
 #include "ui/base/cocoa/focus_window_set.h"
 
 using extensions::ExtensionRegistry;
 
 namespace {
 
-typedef apps::ShellWindowRegistry::ShellWindowList ShellWindowList;
+typedef apps::AppWindowRegistry::AppWindowList AppWindowList;
 
 void ProfileLoadedCallback(base::Callback<void(Profile*)> callback,
                            Profile* profile,
                            Profile::CreateStatus status) {
   if (status == Profile::CREATE_STATUS_INITIALIZED) {
     callback.Run(profile);
     return;
   }
 
   // This should never get an error since it only loads existing profiles.
   DCHECK_EQ(Profile::CREATE_STATUS_CREATED, status);
 }
 
 void SetAppHidden(Profile* profile, const std::string& app_id, bool hidden) {
-  ShellWindowList windows =
-      apps::ShellWindowRegistry::Get(profile)->GetShellWindowsForApp(app_id);
-  for (ShellWindowList::const_reverse_iterator it = windows.rbegin();
-       it != windows.rend(); ++it) {
+  AppWindowList windows =
+      apps::AppWindowRegistry::Get(profile)->GetAppWindowsForApp(app_id);
+  for (AppWindowList::const_reverse_iterator it = windows.rbegin();
+       it != windows.rend();
+       ++it) {
     if (hidden)
       (*it)->GetBaseWindow()->HideWithApp();
     else
       (*it)->GetBaseWindow()->ShowWithApp();
   }
 }
 
-bool FocusWindows(const ShellWindowList& windows) {
+bool FocusWindows(const AppWindowList& windows) {
   if (windows.empty())
     return false;
 
   std::set<gfx::NativeWindow> native_windows;
-  for (ShellWindowList::const_iterator it = windows.begin();
-       it != windows.end(); ++it) {
+  for (AppWindowList::const_iterator it = windows.begin(); it != windows.end();
+       ++it) {
     native_windows.insert((*it)->GetNativeWindow());
   }
   // Allow workspace switching. For the browser process, we can reasonably rely
   // on OS X to switch spaces for us and honor relevant user settings. But shims
   // don't have windows, so we have to do it ourselves.
   ui::FocusWindowSet(native_windows, true);
   return true;
 }
 
 // Attempts to launch a packaged app, prompting the user to enable it if
@@ skipping 66 matching lines @@
     const base::FilePath& path,
     base::Callback<void(Profile*)> callback) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   base::FilePath full_path = profile_manager->user_data_dir().Append(path);
   profile_manager->CreateProfileAsync(
       full_path,
       base::Bind(&ProfileLoadedCallback, callback),
       base::string16(), base::string16(), std::string());
 }
 
-ShellWindowList ExtensionAppShimHandler::Delegate::GetWindows(
+AppWindowList ExtensionAppShimHandler::Delegate::GetWindows(
     Profile* profile,
     const std::string& extension_id) {
-  return ShellWindowRegistry::Get(profile)->GetShellWindowsForApp(extension_id);
+  return AppWindowRegistry::Get(profile)->GetAppWindowsForApp(extension_id);
 }
 
 const extensions::Extension*
 ExtensionAppShimHandler::Delegate::GetAppExtension(
     Profile* profile,
     const std::string& extension_id) {
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
   const extensions::Extension* extension =
       registry->GetExtensionById(extension_id, ExtensionRegistry::ENABLED);
   return extension && extension->is_platform_app() ? extension : NULL;
@@ skipping 49 matching lines @@
 ExtensionAppShimHandler::~ExtensionAppShimHandler() {}
 
 AppShimHandler::Host* ExtensionAppShimHandler::FindHost(
     Profile* profile,
     const std::string& app_id) {
   HostMap::iterator it = hosts_.find(make_pair(profile, app_id));
   return it == hosts_.end() ? NULL : it->second;
 }
 
 // static
-void ExtensionAppShimHandler::QuitAppForWindow(ShellWindow* shell_window) {
+void ExtensionAppShimHandler::QuitAppForWindow(AppWindow* app_window) {
   ExtensionAppShimHandler* handler =
       g_browser_process->platform_part()->app_shim_host_manager()->
           extension_app_shim_handler();
   Host* host = handler->FindHost(
-      Profile::FromBrowserContext(shell_window->browser_context()),
-      shell_window->extension_id());
+      Profile::FromBrowserContext(app_window->browser_context()),
+      app_window->extension_id());
   if (host) {
     handler->OnShimQuit(host);
   } else {
     // App shims might be disabled or the shim is still starting up.
-    ShellWindowRegistry::Get(
-        Profile::FromBrowserContext(shell_window->browser_context()))
-        ->CloseAllShellWindowsForApp(shell_window->extension_id());
+    AppWindowRegistry::Get(
+        Profile::FromBrowserContext(app_window->browser_context()))
+        ->CloseAllAppWindowsForApp(app_window->extension_id());
   }
 }
 
-void ExtensionAppShimHandler::HideAppForWindow(ShellWindow* shell_window) {
+void ExtensionAppShimHandler::HideAppForWindow(AppWindow* app_window) {
   ExtensionAppShimHandler* handler =
       g_browser_process->platform_part()->app_shim_host_manager()->
           extension_app_shim_handler();
-  Profile* profile =
-      Profile::FromBrowserContext(shell_window->browser_context());
-  Host* host = handler->FindHost(profile, shell_window->extension_id());
+  Profile* profile = Profile::FromBrowserContext(app_window->browser_context());
+  Host* host = handler->FindHost(profile, app_window->extension_id());
   if (host)
     host->OnAppHide();
   else
-    SetAppHidden(profile, shell_window->extension_id(), true);
+    SetAppHidden(profile, app_window->extension_id(), true);
 }
 
-
-void ExtensionAppShimHandler::FocusAppForWindow(ShellWindow* shell_window) {
+void ExtensionAppShimHandler::FocusAppForWindow(AppWindow* app_window) {
   ExtensionAppShimHandler* handler =
       g_browser_process->platform_part()->app_shim_host_manager()->
           extension_app_shim_handler();
-  Profile* profile =
-      Profile::FromBrowserContext(shell_window->browser_context());
-  const std::string& app_id = shell_window->extension_id();
+  Profile* profile = Profile::FromBrowserContext(app_window->browser_context());
+  const std::string& app_id = app_window->extension_id();
   Host* host = handler->FindHost(profile, app_id);
   if (host) {
     handler->OnShimFocus(host,
                          APP_SHIM_FOCUS_NORMAL,
                          std::vector<base::FilePath>());
   } else {
     FocusWindows(
-        apps::ShellWindowRegistry::Get(profile)->GetShellWindowsForApp(app_id));
+        apps::AppWindowRegistry::Get(profile)->GetAppWindowsForApp(app_id));
   }
 }
 
 // static
 bool ExtensionAppShimHandler::RequestUserAttentionForWindow(
-    ShellWindow* shell_window) {
+    AppWindow* app_window) {
   ExtensionAppShimHandler* handler =
       g_browser_process->platform_part()->app_shim_host_manager()->
           extension_app_shim_handler();
-  Profile* profile =
-      Profile::FromBrowserContext(shell_window->browser_context());
-  Host* host = handler->FindHost(profile, shell_window->extension_id());
+  Profile* profile = Profile::FromBrowserContext(app_window->browser_context());
+  Host* host = handler->FindHost(profile, app_window->extension_id());
   if (host) {
     // Bring the window to the front without showing it.
-    ShellWindowRegistry::Get(profile)->ShellWindowActivated(shell_window);
+    AppWindowRegistry::Get(profile)->AppWindowActivated(app_window);
     host->OnAppRequestUserAttention();
     return true;
   } else {
     // Just show the app.
-    SetAppHidden(profile, shell_window->extension_id(), false);
+    SetAppHidden(profile, app_window->extension_id(), false);
     return false;
   }
 }
 
 void ExtensionAppShimHandler::OnShimLaunch(
     Host* host,
     AppShimLaunchType launch_type,
     const std::vector<base::FilePath>& files) {
   const std::string& app_id = host->GetAppId();
   DCHECK(extensions::Extension::IdIsValid(app_id));
@@ skipping 106 matching lines @@
   }
 }
 
 void ExtensionAppShimHandler::OnShimFocus(
     Host* host,
     AppShimFocusType focus_type,
     const std::vector<base::FilePath>& files) {
   DCHECK(delegate_->ProfileExistsForPath(host->GetProfilePath()));
   Profile* profile = delegate_->ProfileForPath(host->GetProfilePath());
 
-  const ShellWindowList windows =
+  const AppWindowList windows =
       delegate_->GetWindows(profile, host->GetAppId());
   bool windows_focused = FocusWindows(windows);
 
   if (focus_type == APP_SHIM_FOCUS_NORMAL ||
       (focus_type == APP_SHIM_FOCUS_REOPEN && windows_focused)) {
     return;
   }
 
   const extensions::Extension* extension =
       delegate_->GetAppExtension(profile, host->GetAppId());
@@ skipping 11 matching lines @@
   Profile* profile = delegate_->ProfileForPath(host->GetProfilePath());
 
   SetAppHidden(profile, host->GetAppId(), hidden);
 }
 
 void ExtensionAppShimHandler::OnShimQuit(Host* host) {
   DCHECK(delegate_->ProfileExistsForPath(host->GetProfilePath()));
   Profile* profile = delegate_->ProfileForPath(host->GetProfilePath());
 
   const std::string& app_id = host->GetAppId();
-  const ShellWindowList windows =
-      delegate_->GetWindows(profile, app_id);
-  for (ShellWindowRegistry::const_iterator it = windows.begin();
-       it != windows.end(); ++it) {
+  const AppWindowList windows = delegate_->GetWindows(profile, app_id);
+  for (AppWindowRegistry::const_iterator it = windows.begin();
+       it != windows.end();
+       ++it) {
     (*it)->GetBaseWindow()->Close();
   }
   // Once the last window closes, flow will end up in OnAppDeactivated via
   // AppLifetimeMonitor.
 }
 
 void ExtensionAppShimHandler::set_delegate(Delegate* delegate) {
   delegate_.reset(delegate);
 }
 
@@ skipping 60 matching lines @@
   if (hosts_.empty())
     delegate_->MaybeTerminate();
 }
 
 void ExtensionAppShimHandler::OnAppStop(Profile* profile,
                                         const std::string& app_id) {}
 
 void ExtensionAppShimHandler::OnChromeTerminating() {}
 
 }  // namespace apps