Re-land:

views/window/window.cc

 // 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.
 
 #include "views/window/window.h"
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_font_util.h"
@@ skipping 29 matching lines @@
       window_closed_(false) {
 }
 
 Window::~Window() {
 }
 
 // static
 Window* Window::CreateChromeWindow(gfx::NativeWindow parent,
                                    const gfx::Rect& bounds,
                                    WindowDelegate* window_delegate) {
-  Window* window = NativeWindow::CreateNativeWindow();
+  Window* window = new Window;
   Window::InitParams params(window_delegate);
   params.parent_window = parent;
   params.widget_init_params.bounds = bounds;
   window->InitWindow(params);
   return window;
 }
 
 // static
 int Window::GetLocalizedContentsWidth(int col_resource_id) {
   return ui::GetLocalizedContentsWidthForFont(col_resource_id,
       ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont));
 }
 
 // static
 int Window::GetLocalizedContentsHeight(int row_resource_id) {
   return ui::GetLocalizedContentsHeightForFont(row_resource_id,
       ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont));
 }
 
 // static
 gfx::Size Window::GetLocalizedContentsSize(int col_resource_id,
                                            int row_resource_id) {
   return gfx::Size(GetLocalizedContentsWidth(col_resource_id),
                    GetLocalizedContentsHeight(row_resource_id));
 }
 
-// static
-void Window::CloseSecondaryWidget(Widget* widget) {
-  if (!widget)
-    return;
-
-  // Close widget if it's identified as a secondary window.
-  Window* window = widget->GetWindow();
-  if (window) {
-    if (!window->IsAppWindow())
-      window->CloseWindow();
-  } else {
-    // If it's not a Window, then close it anyway since it probably is
-    // secondary.
-    widget->Close();
-  }
-}
-
 void Window::InitWindow(const InitParams& params) {
   window_delegate_ = params.window_delegate;
   AsWidget()->set_widget_delegate(window_delegate_);
   DCHECK(window_delegate_);
   DCHECK(!window_delegate_->window_);
   window_delegate_->window_ = this;
+  set_widget_delegate(window_delegate_);
+  native_window_ =
+      params.native_window ? params.native_window
+                           : NativeWindow::CreateNativeWindow(this);
   // If frame_view was set already, don't replace it with default one.
   if (!non_client_view()->frame_view())
     non_client_view()->SetFrameView(CreateFrameViewForWindow());
-  AsWidget()->Init(params.widget_init_params);
-  OnNativeWindowCreated(params.widget_init_params.bounds);
+  InitParams modified_params = params;
+  modified_params.widget_init_params.native_widget =
+      native_window_->AsNativeWidget();
+  Init(modified_params.widget_init_params);
+  OnNativeWindowCreated(modified_params.widget_init_params.bounds);
 }
 
 gfx::Rect Window::GetBounds() const {
   // TODO(beng): Clean this up once Window subclasses Widget.
   return native_window_->AsNativeWidget()->GetWidget()->GetWindowScreenBounds();
 }
 
 gfx::Rect Window::GetNormalBounds() const {
   return native_window_->GetRestoredBounds();
 }
@@ skipping 27 matching lines @@
 }
 
 void Window::Activate() {
   native_window_->Activate();
 }
 
 void Window::Deactivate() {
   native_window_->Deactivate();
 }
 
-void Window::CloseWindow() {
+void Window::Close() {
   if (window_closed_) {
     // It appears we can hit this code path if you close a modal dialog then
     // close the last browser before the destructor is hit, which triggers
     // invoking Close again.
     return;
   }
 
   if (non_client_view_->CanClose()) {
     SaveWindowPosition();
-    // TODO(beng): This can be simplified to Widget::Close() once Window
-    //             subclasses Widget.
-    native_window_->AsNativeWidget()->GetWidget()->Close();
+    Widget::Close();
     window_closed_ = true;
   }
 }
 
 void Window::Maximize() {
   native_window_->Maximize();
 }
 
 void Window::Minimize() {
   native_window_->Minimize();
@@ skipping 24 matching lines @@
 }
 
 bool Window::IsFullscreen() const {
   return native_window_->IsFullscreen();
 }
 
 void Window::SetUseDragFrame(bool use_drag_frame) {
   native_window_->SetUseDragFrame(use_drag_frame);
 }
 
-bool Window::IsAppWindow() const {
-  return native_window_->IsAppWindow();
-}
-
 void Window::EnableClose(bool enable) {
   non_client_view_->EnableClose(enable);
   native_window_->EnableClose(enable);
 }
 
 void Window::UpdateWindowTitle() {
   // If the non-client view is rendering its own title, it'll need to relayout
   // now.
   non_client_view_->Layout();
 
@@ skipping 31 matching lines @@
 }
 
 bool Window::ShouldUseNativeFrame() const {
   return native_window_->ShouldUseNativeFrame();
 }
 
 void Window::FrameTypeChanged() {
   native_window_->FrameTypeChanged();
 }
 
-Widget* Window::AsWidget() {
-  return const_cast<Widget*>(const_cast<const Window*>(this)->AsWidget());
-}
-
-const Widget* Window::AsWidget() const {
-  return native_window_->AsNativeWidget()->GetWidget();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Window, protected:
-
-void Window::SetNativeWindow(NativeWindow* native_window) {
-  native_window_ = native_window;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Window, internal::NativeWindowDelegate implementation:
 
 bool Window::CanActivate() const {
   return window_delegate_->CanActivate();
 }
 
 bool Window::IsInactiveRenderingDisabled() const {
   return disable_inactive_rendering_;
 }
@@ skipping 68 matching lines @@
 
 void Window::OnNativeWindowDestroyed() {
   window_delegate_->DeleteDelegate();
   window_delegate_ = NULL;
 }
 
 void Window::OnNativeWindowBoundsChanged() {
   SaveWindowPosition();
 }
 
+Window* Window::AsWindow() {
+  return this;
+}
+
+internal::NativeWidgetDelegate* Window::AsNativeWidgetDelegate() {
+  return this;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Window, private:
 
 void Window::SetInitialBounds(const gfx::Rect& bounds) {
   // First we obtain the window's saved show-style and store it. We need to do
   // this here, rather than in Show() because by the time Show() is called,
   // the window's size will have been reset (below) and the saved maximized
   // state will have been lost. Sadly there's no way to tell on Windows when
   // a window is restored from maximized state, so we can't more accurately
   // track maximized state independently of sizing information.
@@ skipping 46 matching lines @@
   if (!window_delegate_)
     return;
 
   bool maximized;
   gfx::Rect bounds;
   native_window_->GetWindowBoundsAndMaximizedState(&bounds, &maximized);
   window_delegate_->SaveWindowPlacement(bounds, maximized);
 }
 
 }  // namespace views