Rename apps::ShellWindow to apps::AppWindow

apps/app_window.h

 // 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.
 
-#ifndef APPS_SHELL_WINDOW_H_
-#define APPS_SHELL_WINDOW_H_
+#ifndef APPS_APP_WINDOW_H_
+#define APPS_APP_WINDOW_H_
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/extensions/extension_icon_image.h"
 #include "chrome/browser/extensions/extension_keybinding_registry.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "components/web_modal/web_contents_modal_dialog_manager_delegate.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_contents_delegate.h"
@@ skipping 24 matching lines @@
 }
 
 namespace ui {
 class BaseWindow;
 }
 
 namespace apps {
 
 class NativeAppWindow;
 
-// Manages the web contents for Shell Windows. The implementation for this
+// Manages the web contents for app windows. The implementation for this
 // class should create and maintain the WebContents for the window, and handle
 // any message passing between the web contents and the extension system or
 // native window.
-class ShellWindowContents {
+class AppWindowContents {
  public:
-  ShellWindowContents() {}
-  virtual ~ShellWindowContents() {}
+  AppWindowContents() {}
+  virtual ~AppWindowContents() {}
 
   // Called to initialize the WebContents, before the app window is created.
   virtual void Initialize(content::BrowserContext* context,
                           const GURL& url) = 0;
 
   // Called to load the contents, after the app window is created.
   virtual void LoadContents(int32 creator_process_id) = 0;
 
   // Called when the native window changes.
   virtual void NativeWindowChanged(NativeAppWindow* native_app_window) = 0;
 
   // Called when the native window closes.
   virtual void NativeWindowClosed() = 0;
 
   virtual content::WebContents* GetWebContents() const = 0;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ShellWindowContents);
+  DISALLOW_COPY_AND_ASSIGN(AppWindowContents);
 };
 
-// ShellWindow is the type of window used by platform apps. Shell windows
+// AppWindow is the type of window used by platform apps. App windows
 // have a WebContents but none of the chrome of normal browser windows.
-class ShellWindow : public content::NotificationObserver,
-                    public content::WebContentsDelegate,
-                    public content::WebContentsObserver,
-                    public web_modal::WebContentsModalDialogManagerDelegate,
-                    public extensions::ExtensionKeybindingRegistry::Delegate,
-                    public extensions::IconImage::Observer {
+class AppWindow : public content::NotificationObserver,
+                  public content::WebContentsDelegate,
+                  public content::WebContentsObserver,
+                  public web_modal::WebContentsModalDialogManagerDelegate,
+                  public extensions::ExtensionKeybindingRegistry::Delegate,
+                  public extensions::IconImage::Observer {
  public:
   enum WindowType {
-    WINDOW_TYPE_DEFAULT  = 1 << 0,  // Default shell window.
-    WINDOW_TYPE_PANEL    = 1 << 1,  // OS controlled panel window (Ash only).
+    WINDOW_TYPE_DEFAULT = 1 << 0,   // Default app window.
+    WINDOW_TYPE_PANEL = 1 << 1,     // OS controlled panel window (Ash only).
     WINDOW_TYPE_V1_PANEL = 1 << 2,  // For apps v1 support in Ash; deprecate
                                     // with v1 apps.
   };
 
   enum Frame {
     FRAME_CHROME,  // Chrome-style window frame.
-    FRAME_NONE,  // Frameless window.
+    FRAME_NONE,    // Frameless window.
   };
 
   enum FullscreenType {
     // Not fullscreen.
     FULLSCREEN_TYPE_NONE = 0,
 
     // Fullscreen entered by the app.window api.
     FULLSCREEN_TYPE_WINDOW_API = 1 << 0,
 
     // Fullscreen entered by HTML requestFullscreen().
@@ skipping 82 matching lines @@
     bool always_on_top;
   };
 
   class Delegate {
    public:
     virtual ~Delegate();
 
     // General initialization.
     virtual void InitWebContents(content::WebContents* web_contents) = 0;
     virtual NativeAppWindow* CreateNativeAppWindow(
-        ShellWindow* window,
+        AppWindow* window,
         const CreateParams& params) = 0;
 
     // Link handling.
     virtual content::WebContents* OpenURLFromTab(
         content::BrowserContext* context,
         content::WebContents* source,
         const content::OpenURLParams& params) = 0;
     virtual void AddNewContents(content::BrowserContext* context,
                                 content::WebContents* new_contents,
                                 WindowOpenDisposition disposition,
                                 const gfx::Rect& initial_pos,
                                 bool user_gesture,
                                 bool* was_blocked) = 0;
 
     // Feature support.
     virtual content::ColorChooser* ShowColorChooser(
         content::WebContents* web_contents,
         SkColor initial_color) = 0;
     virtual void RunFileChooser(content::WebContents* tab,
                                 const content::FileChooserParams& params) = 0;
     virtual void RequestMediaAccessPermission(
         content::WebContents* web_contents,
         const content::MediaStreamRequest& request,
         const content::MediaResponseCallback& callback,
-      const extensions::Extension* extension) = 0;
+        const extensions::Extension* extension) = 0;
     virtual int PreferredIconSize() = 0;
 
     // Web contents modal dialog support.
     virtual void SetWebContentsBlocked(content::WebContents* web_contents,
                                        bool blocked) = 0;
     virtual bool IsWebContentsVisible(content::WebContents* web_contents) = 0;
   };
 
   // Convert draggable regions in raw format to SkRegion format. Caller is
   // responsible for deleting the returned SkRegion instance.
   static SkRegion* RawDraggableRegionsToSkRegion(
       const std::vector<extensions::DraggableRegion>& regions);
 
-  // The constructor and Init methods are public for constructing a ShellWindow
+  // The constructor and Init methods are public for constructing a AppWindow
   // with a non-standard render interface (e.g. v1 apps using Ash Panels).
-  // Normally ShellWindow::Create should be used.
-  // The constructed shell window takes ownership of |delegate|.
-  ShellWindow(content::BrowserContext* context,
-              Delegate* delegate,
-              const extensions::Extension* extension);
+  // Normally AppWindow::Create should be used.
+  // The constructed app window takes ownership of |delegate|.
+  AppWindow(content::BrowserContext* context,
+            Delegate* delegate,
+            const extensions::Extension* extension);
 
   // Initializes the render interface, web contents, and native window.
-  // |shell_window_contents| will become owned by ShellWindow.
+  // |app_window_contents| will become owned by AppWindow.
   void Init(const GURL& url,
-            ShellWindowContents* shell_window_contents,
+            AppWindowContents* app_window_contents,
             const CreateParams& params);
 
-
   const std::string& window_key() const { return window_key_; }
   const SessionID& session_id() const { return session_id_; }
   const extensions::Extension* extension() const { return extension_; }
   const std::string& extension_id() const { return extension_id_; }
   content::WebContents* web_contents() const;
   WindowType window_type() const { return window_type_; }
   bool window_type_is_panel() const {
     return (window_type_ == WINDOW_TYPE_PANEL ||
             window_type_ == WINDOW_TYPE_V1_PANEL);
   }
@@ skipping 55 matching lines @@
   void OSFullscreen();
 
   // Transitions to forced fullscreen. See FULLSCREEN_TYPE_FORCED for more
   // details.
   void ForcedFullscreen();
 
   // Set the minimum and maximum size that this window is allowed to be.
   void SetMinimumSize(const gfx::Size& min_size);
   void SetMaximumSize(const gfx::Size& max_size);
 
-  enum ShowType {
-    SHOW_ACTIVE,
-    SHOW_INACTIVE
-  };
+  enum ShowType { SHOW_ACTIVE, SHOW_INACTIVE };
 
   // Shows the window if its contents have been painted; otherwise flags the
   // window to be shown as soon as its contents are painted for the first time.
   void Show(ShowType show_type);
 
   // Hides the window. If the window was previously flagged to be shown on
   // first paint, it will be unflagged.
   void Hide();
 
-  ShellWindowContents* shell_window_contents_for_test() {
-    return shell_window_contents_.get();
+  AppWindowContents* app_window_contents_for_test() {
+    return app_window_contents_.get();
   }
 
   // Get the size constraints.
-  const SizeConstraints& size_constraints() const {
-    return size_constraints_;
-  }
+  const SizeConstraints& size_constraints() const { return size_constraints_; }
 
   // Set whether the window should stay above other windows which are not
   // configured to be always-on-top.
   void SetAlwaysOnTop(bool always_on_top);
 
   // Whether the always-on-top property has been set by the chrome.app.window
   // API. Note that the actual value of this property in the native app window
   // may be false if the bit is silently switched off for security reasons.
   bool IsAlwaysOnTop() const;
 
   // Retrieve the current state of the app window as a dictionary, to pass to
   // the renderer.
   void GetSerializedState(base::DictionaryValue* properties) const;
 
  protected:
-  virtual ~ShellWindow();
+  virtual ~AppWindow();
 
  private:
   // PlatformAppBrowserTest needs access to web_contents()
   friend class extensions::PlatformAppBrowserTest;
 
   // content::WebContentsDelegate implementation.
   virtual void CloseContents(content::WebContents* contents) OVERRIDE;
   virtual bool ShouldSuppressDialogs() OVERRIDE;
   virtual content::ColorChooser* OpenColorChooser(
       content::WebContents* web_contents,
       SkColor color,
       const std::vector<content::ColorSuggestion>& suggestions) OVERRIDE;
-  virtual void RunFileChooser(
-      content::WebContents* tab,
-      const content::FileChooserParams& params) OVERRIDE;
-  virtual bool IsPopupOrPanel(
-      const content::WebContents* source) const OVERRIDE;
-  virtual void MoveContents(
-      content::WebContents* source, const gfx::Rect& pos) OVERRIDE;
+  virtual void RunFileChooser(content::WebContents* tab,
+                              const content::FileChooserParams& params)
+      OVERRIDE;
+  virtual bool IsPopupOrPanel(const content::WebContents* source)
+      const OVERRIDE;
+  virtual void MoveContents(content::WebContents* source,
+                            const gfx::Rect& pos) OVERRIDE;
   virtual void NavigationStateChanged(const content::WebContents* source,
                                       unsigned changed_flags) OVERRIDE;
   virtual void ToggleFullscreenModeForTab(content::WebContents* source,
                                           bool enter_fullscreen) OVERRIDE;
-  virtual bool IsFullscreenForTabOrPending(
-      const content::WebContents* source) const OVERRIDE;
+  virtual bool IsFullscreenForTabOrPending(const content::WebContents* source)
+      const OVERRIDE;
   virtual void RequestMediaAccessPermission(
       content::WebContents* web_contents,
       const content::MediaStreamRequest& request,
       const content::MediaResponseCallback& callback) OVERRIDE;
   virtual content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) OVERRIDE;
   virtual void AddNewContents(content::WebContents* source,
                               content::WebContents* new_contents,
                               WindowOpenDisposition disposition,
                               const gfx::Rect& initial_pos,
                               bool user_gesture,
                               bool* was_blocked) OVERRIDE;
   virtual bool PreHandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event,
       bool* is_keyboard_shortcut) OVERRIDE;
-  virtual void HandleKeyboardEvent(
-      content::WebContents* source,
-      const content::NativeWebKeyboardEvent& event) OVERRIDE;
+  virtual void HandleKeyboardEvent(content::WebContents* source,
+                                   const content::NativeWebKeyboardEvent& event)
+      OVERRIDE;
   virtual void RequestToLockMouse(content::WebContents* web_contents,
                                   bool user_gesture,
                                   bool last_unlocked_by_target) OVERRIDE;
-  virtual bool PreHandleGestureEvent(
-      content::WebContents* source,
-      const blink::WebGestureEvent& event) OVERRIDE;
+  virtual bool PreHandleGestureEvent(content::WebContents* source,
+                                     const blink::WebGestureEvent& event)
+      OVERRIDE;
 
   // content::WebContentsObserver implementation.
   virtual void DidFirstVisuallyNonEmptyPaint(int32 page_id) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // web_modal::WebContentsModalDialogManagerDelegate implementation.
   virtual void SetWebContentsBlocked(content::WebContents* web_contents,
                                      bool blocked) OVERRIDE;
-  virtual bool IsWebContentsVisible(
-      content::WebContents* web_contents) OVERRIDE;
+  virtual bool IsWebContentsVisible(content::WebContents* web_contents)
+      OVERRIDE;
 
   // Helper method to add a message to the renderer's DevTools console.
   void AddMessageToDevToolsConsole(content::ConsoleMessageLevel level,
                                    const std::string& message);
 
   // Saves the window geometry/position/screen bounds.
   void SaveWindowPosition();
 
   // Helper method to adjust the cached bounds so that we can make sure it can
   // be visible on the screen. See http://crbug.com/145752 .
-  void AdjustBoundsToBeVisibleOnScreen(
-      const gfx::Rect& cached_bounds,
-      const gfx::Rect& cached_screen_bounds,
-      const gfx::Rect& current_screen_bounds,
-      const gfx::Size& minimum_size,
-      gfx::Rect* bounds) const;
+  void AdjustBoundsToBeVisibleOnScreen(const gfx::Rect& cached_bounds,
+                                       const gfx::Rect& cached_screen_bounds,
+                                       const gfx::Rect& current_screen_bounds,
+                                       const gfx::Size& minimum_size,
+                                       gfx::Rect* bounds) const;
 
   // Loads the appropriate default or cached window bounds and constrains them
   // based on screen size and minimum/maximum size. Returns a new CreateParams
   // that should be used to create the window.
   CreateParams LoadDefaultsAndConstrain(CreateParams params) const;
 
   // Load the app's image, firing a load state change when loaded.
   void UpdateExtensionAppIcon();
 
   // Called when size_constraints is changed.
   void OnSizeConstraintsChanged();
 
   // Set the fullscreen state in the native app window.
   void SetNativeWindowFullscreen();
 
   // Returns true if there is any overlap between the window and the taskbar
   // (Windows only).
   bool IntersectsWithTaskbar() const;
 
   // Update the always-on-top bit in the native app window.
   void UpdateNativeAlwaysOnTop();
 
   // extensions::ExtensionKeybindingRegistry::Delegate implementation.
   virtual extensions::ActiveTabPermissionGranter*
       GetActiveTabPermissionGranter() OVERRIDE;
 
   // web_modal::WebContentsModalDialogManagerDelegate implementation.
-  virtual web_modal::WebContentsModalDialogHost*
-      GetWebContentsModalDialogHost() OVERRIDE;
+  virtual web_modal::WebContentsModalDialogHost* GetWebContentsModalDialogHost()
+      OVERRIDE;
 
   // Updates the badge to |image|. Called internally from the image loader
   // callback.
   void UpdateBadgeIcon(const gfx::Image& image);
 
   // Callback from web_contents()->DownloadFavicon.
   void DidDownloadFavicon(int id,
                           int http_status_code,
                           const GURL& image_url,
                           const std::vector<SkBitmap>& bitmaps,
                           const std::vector<gfx::Size>& original_bitmap_sizes);
 
   // extensions::IconImage::Observer implementation.
-  virtual void OnExtensionIconImageChanged(
-      extensions::IconImage* image) OVERRIDE;
+  virtual void OnExtensionIconImageChanged(extensions::IconImage* image)
+      OVERRIDE;
 
-  // The browser context with which this window is associated. ShellWindow does
+  // The browser context with which this window is associated. AppWindow does
   // not own this object.
   content::BrowserContext* browser_context_;
 
   // weak pointer - owned by ExtensionService.
   const extensions::Extension* extension_;
   const std::string extension_id_;
 
   // Identifier that is used when saving and restoring geometry for this
   // window.
   std::string window_key_;
@@ skipping 15 matching lines @@
   // Badge for icon shown in the task bar.
   gfx::Image badge_icon_;
 
   // URL to be used for setting the badge on the app icon.
   GURL badge_icon_url_;
 
   // An object to load the badge as an extension resource.
   scoped_ptr<extensions::IconImage> badge_icon_image_;
 
   scoped_ptr<NativeAppWindow> native_app_window_;
-  scoped_ptr<ShellWindowContents> shell_window_contents_;
+  scoped_ptr<AppWindowContents> app_window_contents_;
   scoped_ptr<Delegate> delegate_;
 
-  base::WeakPtrFactory<ShellWindow> image_loader_ptr_factory_;
+  base::WeakPtrFactory<AppWindow> image_loader_ptr_factory_;
 
   // Bit field of FullscreenType.
   int fullscreen_types_;
 
   // Size constraints on the window.
   SizeConstraints size_constraints_;
 
   // Show has been called, so the window should be shown once the first visually
   // non-empty paint occurs.
   bool show_on_first_paint_;
 
   // The first visually non-empty paint has completed.
   bool first_paint_complete_;
 
   // Whether the delayed Show() call was for an active or inactive window.
   ShowType delayed_show_type_;
 
   // Cache the desired value of the always-on-top property. When windows enter
   // fullscreen or overlap the Windows taskbar, this property will be
   // automatically and silently switched off for security reasons. It is
   // reinstated when the window exits fullscreen and moves away from the
   // taskbar.
   bool cached_always_on_top_;
 
-  DISALLOW_COPY_AND_ASSIGN(ShellWindow);
+  DISALLOW_COPY_AND_ASSIGN(AppWindow);
 };
 
 }  // namespace apps
 
-#endif  // APPS_SHELL_WINDOW_H_
+#endif  // APPS_APP_WINDOW_H_