Rename apps::ShellWindow to apps::AppWindow

chrome/browser/extensions/api/tabs/ash_panel_contents.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/extensions/api/tabs/ash_panel_contents.h"
 
 #include "apps/ui/native_app_window.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs_windows_api.h"
 #include "chrome/browser/extensions/api/tabs/windows_event_router.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/window_controller_list.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/extension.h"
 #include "ui/gfx/image/image.h"
 
-using apps::ShellWindow;
+using apps::AppWindow;
 using apps::NativeAppWindow;
 
 // AshPanelWindowController ----------------------------------------------------
 
-// This class enables a ShellWindow instance to be accessed (to a limited
+// This class enables an AppWindow instance to be accessed (to a limited
 // extent) via the chrome.windows and chrome.tabs API. This is a temporary
-// bridge to support instantiating ShellWindows from v1 apps, specifically
+// bridge to support instantiating AppWindows from v1 apps, specifically
 // for creating Panels in Ash. See crbug.com/160645.
 class AshPanelWindowController : public extensions::WindowController {
  public:
-  AshPanelWindowController(ShellWindow* window, Profile* profile);
+  AshPanelWindowController(AppWindow* window, Profile* profile);
   virtual ~AshPanelWindowController();
 
   void NativeWindowChanged();
 
   // Overridden from extensions::WindowController.
   virtual int GetWindowId() const OVERRIDE;
   virtual std::string GetWindowTypeText() const OVERRIDE;
   virtual base::DictionaryValue* CreateWindowValueWithTabs(
       const extensions::Extension* extension) const OVERRIDE;
   virtual base::DictionaryValue* CreateTabValue(
       const extensions::Extension* extension, int tab_index) const OVERRIDE;
   virtual bool CanClose(Reason* reason) const OVERRIDE;
   virtual void SetFullscreenMode(bool is_fullscreen,
                                  const GURL& extension_url) const OVERRIDE;
   virtual bool IsVisibleToExtension(
       const extensions::Extension* extension) const OVERRIDE;
 
  private:
-  ShellWindow* shell_window_;  // Weak pointer; this is owned by shell_window_
+  AppWindow* app_window_;  // Weak pointer; this is owned by app_window_
   bool is_active_;
 
   DISALLOW_COPY_AND_ASSIGN(AshPanelWindowController);
 };
 
-AshPanelWindowController::AshPanelWindowController(
-    ShellWindow* shell_window, Profile* profile)
-    : extensions::WindowController(shell_window->GetBaseWindow(), profile),
-      shell_window_(shell_window),
-      is_active_(shell_window->GetBaseWindow()->IsActive()) {
+AshPanelWindowController::AshPanelWindowController(AppWindow* app_window,
+                                                   Profile* profile)
+    : extensions::WindowController(app_window->GetBaseWindow(), profile),
+      app_window_(app_window),
+      is_active_(app_window->GetBaseWindow()->IsActive()) {
   extensions::WindowControllerList::GetInstance()->AddExtensionWindow(this);
 }
 
 AshPanelWindowController::~AshPanelWindowController() {
   extensions::WindowControllerList::GetInstance()->RemoveExtensionWindow(this);
 }
 
 int AshPanelWindowController::GetWindowId() const {
-  return static_cast<int>(shell_window_->session_id().id());
+  return static_cast<int>(app_window_->session_id().id());
 }
 
 std::string AshPanelWindowController::GetWindowTypeText() const {
   return extensions::tabs_constants::kWindowTypeValuePanel;
 }
 
 base::DictionaryValue* AshPanelWindowController::CreateWindowValueWithTabs(
     const extensions::Extension* extension) const {
   DCHECK(IsVisibleToExtension(extension));
   base::DictionaryValue* result = CreateWindowValue();
   base::DictionaryValue* tab_value = CreateTabValue(extension, 0);
   if (tab_value) {
     base::ListValue* tab_list = new base::ListValue();
     tab_list->Append(tab_value);
     result->Set(extensions::tabs_constants::kTabsKey, tab_list);
   }
   return result;
 }
 
 base::DictionaryValue* AshPanelWindowController::CreateTabValue(
     const extensions::Extension* extension, int tab_index) const {
   if ((extension && !IsVisibleToExtension(extension)) ||
       (tab_index > 0)) {
     return NULL;
   }
-  content::WebContents* web_contents = shell_window_->web_contents();
+  content::WebContents* web_contents = app_window_->web_contents();
   if (!web_contents)
     return NULL;
 
   base::DictionaryValue* tab_value = new base::DictionaryValue();
   tab_value->SetInteger(extensions::tabs_constants::kIdKey,
                         SessionID::IdForTab(web_contents));
   tab_value->SetInteger(extensions::tabs_constants::kIndexKey, 0);
   const int window_id = GetWindowId();
   tab_value->SetInteger(extensions::tabs_constants::kWindowIdKey, window_id);
   tab_value->SetString(
       extensions::tabs_constants::kUrlKey, web_contents->GetURL().spec());
   tab_value->SetString(
       extensions::tabs_constants::kStatusKey,
       extensions::ExtensionTabUtil::GetTabStatusText(
           web_contents->IsLoading()));
-  tab_value->SetBoolean(
-      extensions::tabs_constants::kActiveKey,
-      shell_window_->GetBaseWindow()->IsActive());
-  // ShellWindow only ever contains one tab, so that tab is always effectively
+  tab_value->SetBoolean(extensions::tabs_constants::kActiveKey,
+                        app_window_->GetBaseWindow()->IsActive());
+  // AppWindow only ever contains one tab, so that tab is always effectively
   // selcted and highlighted (for purposes of the chrome.tabs API).
   tab_value->SetInteger(extensions::tabs_constants::kWindowIdKey, window_id);
   tab_value->SetInteger(extensions::tabs_constants::kIdKey, window_id);
   tab_value->SetBoolean(extensions::tabs_constants::kSelectedKey, true);
   tab_value->SetBoolean(extensions::tabs_constants::kHighlightedKey, true);
   tab_value->SetBoolean(extensions::tabs_constants::kPinnedKey, false);
   tab_value->SetString(
       extensions::tabs_constants::kTitleKey, web_contents->GetTitle());
   tab_value->SetBoolean(
       extensions::tabs_constants::kIncognitoKey,
       web_contents->GetBrowserContext()->IsOffTheRecord());
   return tab_value;
 }
 
 bool AshPanelWindowController::CanClose(Reason* reason) const {
   return true;
 }
 
 void AshPanelWindowController::SetFullscreenMode(
     bool is_fullscreen, const GURL& extension_url) const {
   // Do nothing. Panels cannot be fullscreen.
 }
 
 bool AshPanelWindowController::IsVisibleToExtension(
     const extensions::Extension* extension) const {
-  return shell_window_->extension() &&
-      extension->id() == shell_window_->extension()->id();
+  return app_window_->extension() &&
+         extension->id() == app_window_->extension()->id();
 }
 
 void AshPanelWindowController::NativeWindowChanged() {
-  bool active = shell_window_->GetBaseWindow()->IsActive();
+  bool active = app_window_->GetBaseWindow()->IsActive();
   if (active == is_active_)
     return;
   is_active_ = active;
   // Let the extension API know that the active window changed.
   extensions::TabsWindowsAPI* tabs_windows_api =
       extensions::TabsWindowsAPI::Get(profile());
   if (!tabs_windows_api)
     return;
   tabs_windows_api->windows_event_router()->OnActiveWindowChanged(
       active ? this : NULL);
 }
 
 // AshPanelContents -----------------------------------------------------
 
-AshPanelContents::AshPanelContents(ShellWindow* host)
-    : host_(host) {
-}
+AshPanelContents::AshPanelContents(AppWindow* host) : host_(host) {}
 
 AshPanelContents::~AshPanelContents() {
 }
 
 void AshPanelContents::Initialize(content::BrowserContext* context,
                                   const GURL& url) {
   url_ = url;
 
   extension_function_dispatcher_.reset(
       new ExtensionFunctionDispatcher(context, this));
 
   web_contents_.reset(
       content::WebContents::Create(content::WebContents::CreateParams(
           context, content::SiteInstance::CreateForURL(context, url_))));
 
   // Needed to give the web contents a Window ID. Extension APIs expect web
   // contents to have a Window ID. Also required for FaviconTabHelper to
   // correctly set the window icon and title.
   SessionTabHelper::CreateForWebContents(web_contents_.get());
   SessionTabHelper::FromWebContents(web_contents_.get())->SetWindowID(
       host_->session_id());
 
   // Responsible for loading favicons for the Launcher, which uses different
   // logic than the FaviconTabHelper associated with web_contents_
-  // (instantiated in ShellWindow::Init())
+  // (instantiated in AppWindow::Init())
   launcher_favicon_loader_.reset(
       new LauncherFaviconLoader(this, web_contents_.get()));
 
   content::WebContentsObserver::Observe(web_contents_.get());
 }
 
 void AshPanelContents::LoadContents(int32 creator_process_id) {
   // This must be created after the native window has been created.
   window_controller_.reset(new AshPanelWindowController(
       host_, Profile::FromBrowserContext(host_->browser_context())));
@@ skipping 37 matching lines @@
 
 content::WebContents* AshPanelContents::GetAssociatedWebContents() const {
   return web_contents_.get();
 }
 
 void AshPanelContents::OnRequest(
     const ExtensionHostMsg_Request_Params& params) {
   extension_function_dispatcher_->Dispatch(
       params, web_contents_->GetRenderViewHost());
 }