Move AppWindow to extensions

extensions/browser/app_window/app_window.h

 // Copyright 2014 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_APP_WINDOW_H_
-#define APPS_APP_WINDOW_H_
+#ifndef EXTENSIONS_BROWSER_APP_WINDOW_APP_WINDOW_H_
+#define EXTENSIONS_BROWSER_APP_WINDOW_APP_WINDOW_H_
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "components/sessions/session_id.h"
 #include "components/web_modal/popup_manager.h"
 #include "components/web_modal/web_contents_modal_dialog_manager_delegate.h"
 #include "content/public/browser/notification_observer.h"
@@ skipping 10 matching lines @@
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace content {
 class BrowserContext;
 class WebContents;
 }
 
+namespace ui {
+class BaseWindow;
+}
+
 namespace extensions {
+
 class AppDelegate;
 class AppWebContentsHelper;
 class Extension;
 class NativeAppWindow;
 class PlatformAppBrowserTest;
 class WindowController;
 
 struct DraggableRegion;
-}
-
-namespace ui {
-class BaseWindow;
-}
-
-namespace apps {
 
 // 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 AppWindowContents {
  public:
   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(
-      extensions::NativeAppWindow* native_app_window) = 0;
+  virtual void NativeWindowChanged(NativeAppWindow* native_app_window) = 0;
 
   // Called when the native window closes.
   virtual void NativeWindowClosed() = 0;
 
   // Called in tests when the window is shown
   virtual void DispatchWindowShownForTests() const = 0;
 
   virtual content::WebContents* GetWebContents() const = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppWindowContents);
 };
 
 // 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 AppWindow : public content::NotificationObserver,
                   public content::WebContentsDelegate,
                   public content::WebContentsObserver,
                   public web_modal::WebContentsModalDialogManagerDelegate,
-                  public extensions::IconImage::Observer {
+                  public IconImage::Observer {
  public:
   enum WindowType {
     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.
@@ skipping 89 matching lines @@
     // constraints.
     gfx::Size GetContentMinimumSize(const gfx::Insets& frame_insets) const;
     gfx::Size GetContentMaximumSize(const gfx::Insets& frame_insets) const;
     gfx::Size GetWindowMinimumSize(const gfx::Insets& frame_insets) const;
     gfx::Size GetWindowMaximumSize(const gfx::Insets& frame_insets) const;
   };
 
   // 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);
+      const std::vector<DraggableRegion>& regions);
 
   // 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 AppWindow::Create should be used.
   // Takes ownership of |app_delegate| and |delegate|.
   AppWindow(content::BrowserContext* context,
-            extensions::AppDelegate* app_delegate,
-            const extensions::Extension* extension);
+            AppDelegate* app_delegate,
+            const Extension* extension);
 
   // Initializes the render interface, web contents, and native window.
   // |app_window_contents| will become owned by AppWindow.
   void Init(const GURL& url,
             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 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);
   }
   content::BrowserContext* browser_context() const { return browser_context_; }
   const gfx::Image& app_icon() const { return app_icon_; }
   const GURL& app_icon_url() const { return app_icon_url_; }
   const gfx::Image& badge_icon() const { return badge_icon_; }
   const GURL& badge_icon_url() const { return badge_icon_url_; }
   bool is_hidden() const { return is_hidden_; }
 
-  const extensions::Extension* GetExtension() const;
-  extensions::NativeAppWindow* GetBaseWindow();
+  const Extension* GetExtension() const;
+  NativeAppWindow* GetBaseWindow();
   gfx::NativeWindow GetNativeWindow();
 
   // Returns the bounds that should be reported to the renderer.
   gfx::Rect GetClientBounds() const;
 
   // NativeAppWindows should call this to determine what the window's title
   // is on startup and from within UpdateWindowTitle().
   base::string16 GetTitle() const;
 
   // Call to notify ShellRegistry and delete the window. Subclasses should
@@ skipping 13 matching lines @@
   // Specifies a url for the window badge.
   void SetBadgeIconUrl(const GURL& icon_url);
 
   // Clear the current badge.
   void ClearBadge();
 
   // Set the window shape. Passing a NULL |region| sets the default shape.
   void UpdateShape(scoped_ptr<SkRegion> region);
 
   // Called from the render interface to modify the draggable regions.
-  void UpdateDraggableRegions(
-      const std::vector<extensions::DraggableRegion>& regions);
+  void UpdateDraggableRegions(const std::vector<DraggableRegion>& regions);
 
   // Updates the app image to |image|. Called internally from the image loader
   // callback. Also called externally for v1 apps using Ash Panels.
   void UpdateAppIcon(const gfx::Image& image);
 
   // Enable or disable fullscreen mode. |type| specifies which type of
   // fullscreen mode to change (note that disabling one type of fullscreen may
   // not exit fullscreen mode because a window may have a different type of
   // fullscreen enabled). If |type| is not FORCED, checks that the extension has
   // the required permission.
@@ skipping 68 matching lines @@
 
   void SetAppWindowContentsForTesting(scoped_ptr<AppWindowContents> contents) {
     app_window_contents_ = contents.Pass();
   }
 
  protected:
   virtual ~AppWindow();
 
  private:
   // PlatformAppBrowserTest needs access to web_contents()
-  friend class extensions::PlatformAppBrowserTest;
+  friend class 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)
@@ skipping 90 matching lines @@
   // 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;
+  // IconImage::Observer implementation.
+  virtual void OnExtensionIconImageChanged(IconImage* image) OVERRIDE;
 
   // The browser context with which this window is associated. AppWindow does
   // not own this object.
   content::BrowserContext* browser_context_;
 
   const std::string extension_id_;
 
   // Identifier that is used when saving and restoring geometry for this
   // window.
   std::string window_key_;
 
   const SessionID session_id_;
   WindowType window_type_;
   content::NotificationRegistrar registrar_;
 
   // Icon shown in the task bar.
   gfx::Image app_icon_;
 
   // Icon URL to be used for setting the app icon. If not empty, app_icon_ will
   // be fetched and set using this URL.
   GURL app_icon_url_;
 
   // An object to load the app's icon as an extension resource.
-  scoped_ptr<extensions::IconImage> app_icon_image_;
+  scoped_ptr<IconImage> app_icon_image_;
 
   // 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<IconImage> badge_icon_image_;
 
-  scoped_ptr<extensions::NativeAppWindow> native_app_window_;
+  scoped_ptr<NativeAppWindow> native_app_window_;
   scoped_ptr<AppWindowContents> app_window_contents_;
-  scoped_ptr<extensions::AppDelegate> app_delegate_;
-  scoped_ptr<extensions::AppWebContentsHelper> helper_;
+  scoped_ptr<AppDelegate> app_delegate_;
+  scoped_ptr<AppWebContentsHelper> helper_;
 
   // Manages popup windows (bubbles, tab-modals) visible overlapping the
   // app window.
   scoped_ptr<web_modal::PopupManager> popup_manager_;
 
   base::WeakPtrFactory<AppWindow> image_loader_ptr_factory_;
 
   // Bit field of FullscreenType.
   int fullscreen_types_;
 
@@ skipping 27 matching lines @@
   // reinstated when the window exits fullscreen and moves away from the
   // taskbar.
   bool cached_always_on_top_;
 
   // Whether |alpha_enabled| was set in the CreateParams.
   bool requested_alpha_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(AppWindow);
 };
 
-}  // namespace apps
+}  // namespace extensions
 
-#endif  // APPS_APP_WINDOW_H_
+#endif  // EXTENSIONS_BROWSER_APP_WINDOW_APP_WINDOW_H_