Re-land:

views/window/window.h

 // Copyright (c) 2011 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 VIEWS_WINDOW_WINDOW_H_
 #define VIEWS_WINDOW_WINDOW_H_
 #pragma once
 
 #include "ui/gfx/native_widget_types.h"
 #include "views/widget/widget.h"
@@ skipping 21 matching lines @@
 //
 //  TODO(beng): Subclass Widget as part of V2.
 //
 //  TODO(beng): Note that this class being non-abstract means that we have a
 //              violation of Google style in that we are using multiple
 //              inheritance. The intention is to split this into a separate
 //              object associated with but not equal to a NativeWidget
 //              implementation. Multiple inheritance is required for this
 //              transitional step.
 //
-class Window : public internal::NativeWindowDelegate {
+class Window : public Widget,
+               public internal::NativeWindowDelegate {
  public:
   struct InitParams {
     // |window_delegate| cannot be NULL.
     explicit InitParams(WindowDelegate* window_delegate);
 
     WindowDelegate* window_delegate;
     gfx::NativeWindow parent_window;
     NativeWindow* native_window;
     Widget::InitParams widget_init_params;
   };
@@ skipping 11 matching lines @@
   // Returns the preferred size of the contents view of this window based on
   // its localized size data. The width in cols is held in a localized string
   // resource identified by |col_resource_id|, the height in the same fashion.
   // TODO(beng): This should eventually live somewhere else, probably closer to
   //             ClientView.
   static int GetLocalizedContentsWidth(int col_resource_id);
   static int GetLocalizedContentsHeight(int row_resource_id);
   static gfx::Size GetLocalizedContentsSize(int col_resource_id,
                                             int row_resource_id);
 
-  // Closes all windows that aren't identified as "app windows" via
-  // IsAppWindow. Called during application shutdown when the last "app window"
-  // is closed.
-  static void CloseAllSecondaryWindows();
-
-  // Used by |CloseAllSecondaryWindows|. If |widget|'s window is a secondary
-  // window, the window is closed. If |widget| has no window, it is closed.
-  // Does nothing if |widget| is null.
-  static void CloseSecondaryWidget(Widget* widget);
-
   // Initializes the window. Must be called before any post-configuration
   // operations are performed.
   void InitWindow(const InitParams& params);
 
   // Retrieves the window's bounds, including its frame.
   gfx::Rect GetBounds() const;
 
   // Retrieves the restored bounds for the window.
   gfx::Rect GetNormalBounds() const;
 
@@ skipping 23 matching lines @@
   // Activates the window, assuming it already exists and is visible.
   void Activate();
 
   // Deactivates the window, making the next window in the Z order the active
   // window.
   void Deactivate();
 
   // Closes the window, ultimately destroying it. The window hides immediately,
   // and is destroyed after a return to the message loop. Close() can be called
   // multiple times.
-  void CloseWindow();
+  virtual void Close() OVERRIDE;
 
   // Maximizes/minimizes/restores the window.
   void Maximize();
   void Minimize();
   void Restore();
 
   // Whether or not the window is currently active.
   bool IsActive() const;
 
   // Whether or not the window is currently visible.
   bool IsVisible() const;
 
   // Whether or not the window is maximized or minimized.
-  bool IsMaximized() const;
+  virtual bool IsMaximized() const;
   bool IsMinimized() const;
 
   // Accessors for fullscreen state.
   void SetFullscreen(bool fullscreen);
   bool IsFullscreen() const;
 
   // Sets whether or not the window should show its frame as a "transient drag
   // frame" - slightly transparent and without the standard window controls.
   void SetUseDragFrame(bool use_drag_frame);
 
-  // Returns true if the Window is considered to be an "app window" - i.e.
-  // any window which when it is the last of its type closed causes the
-  // application to exit.
-  virtual bool IsAppWindow() const;
-
   // Toggles the enable state for the Close button (and the Close menu item in
   // the system menu).
   void EnableClose(bool enable);
 
   // Tell the window to update its title from the delegate.
   void UpdateWindowTitle();
 
   // Tell the window to update its icon from the delegate.
   void UpdateWindowIcon();
 
   // Sets whether or not the window is always-on-top.
   void SetIsAlwaysOnTop(bool always_on_top);
 
   // Creates an appropriate NonClientFrameView for this window.
   virtual NonClientFrameView* CreateFrameViewForWindow();
 
   // Updates the frame after an event caused it to be changed.
   virtual void UpdateFrameAfterFrameChange();
 
   // Retrieves the Window's native window handle.
   gfx::NativeWindow GetNativeWindow() const;
 
   // Whether we should be using a native frame.
   bool ShouldUseNativeFrame() const;
 
   // Tell the window that something caused the frame type to change.
   void FrameTypeChanged();
 
-  // TODO(beng): remove once Window subclasses Widget.
-  Widget* AsWidget();
-  const Widget* AsWidget() const;
-
   WindowDelegate* window_delegate() {
     return const_cast<WindowDelegate*>(
         const_cast<const Window*>(this)->window_delegate());
   }
   const WindowDelegate* window_delegate() const {
     return window_delegate_;
   }
 
   NonClientView* non_client_view() {
     return const_cast<NonClientView*>(
         const_cast<const Window*>(this)->non_client_view());
   }
   const NonClientView* non_client_view() const {
     return non_client_view_;
   }
 
   ClientView* client_view() {
     return const_cast<ClientView*>(
         const_cast<const Window*>(this)->client_view());
   }
   const ClientView* client_view() const {
     return non_client_view()->client_view();
   }
 
   NativeWindow* native_window() { return native_window_; }
 
  protected:
-  // TODO(beng): Temporarily provided as a way to associate the subclass'
-  //             implementation of NativeWidget with this.
-  void SetNativeWindow(NativeWindow* native_window);
-
   // Overridden from NativeWindowDelegate:
   virtual bool CanActivate() const OVERRIDE;
   virtual bool IsInactiveRenderingDisabled() const OVERRIDE;
   virtual void EnableInactiveRendering() OVERRIDE;
   virtual bool IsModal() const OVERRIDE;
   virtual bool IsDialogBox() const OVERRIDE;
   virtual bool IsUsingNativeFrame() const OVERRIDE;
   virtual gfx::Size GetMinimumSize() const OVERRIDE;
   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
   virtual bool ExecuteCommand(int command_id) OVERRIDE;
   virtual void OnNativeWindowCreated(const gfx::Rect& bounds) OVERRIDE;
   virtual void OnNativeWindowActivationChanged(bool active) OVERRIDE;
   virtual void OnNativeWindowBeginUserBoundsChange() OVERRIDE;
   virtual void OnNativeWindowEndUserBoundsChange() OVERRIDE;
   virtual void OnNativeWindowDestroying() OVERRIDE;
   virtual void OnNativeWindowDestroyed() OVERRIDE;
   virtual void OnNativeWindowBoundsChanged() OVERRIDE;
+  virtual Window* AsWindow() OVERRIDE;
+  virtual internal::NativeWidgetDelegate* AsNativeWidgetDelegate() OVERRIDE;
 
  private:
   // Sizes and positions the window just after it is created.
   void SetInitialBounds(const gfx::Rect& bounds);
 
   // Persists the window's restored position and maximized state using the
   // window delegate.
   void SaveWindowPosition();
 
   NativeWindow* native_window_;
@@ skipping 20 matching lines @@
 
   // Set to true if the window is in the process of closing .
   bool window_closed_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace views
 
 #endif  // #ifndef VIEWS_WINDOW_WINDOW_H_