Re-land:

views/window/window_win.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_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/i18n/rtl.h"
@@ skipping 215 matching lines @@
   }
 
  private:
   // The window having its style changed.
   WindowWin* window_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowWin, public:
 
+WindowWin::WindowWin(internal::NativeWindowDelegate* delegate)
+    : WidgetWin(delegate->AsNativeWidgetDelegate()),
+      delegate_(delegate),
+      focus_on_creation_(true),
+      restored_enabled_(false),
+      fullscreen_(false),
+      is_active_(false),
+      lock_updates_(false),
+      saved_window_style_(0),
+      ignore_window_pos_changes_(false),
+      ignore_pos_changes_factory_(this),
+      force_hidden_count_(0),
+      is_right_mouse_pressed_on_caption_(false),
+      last_monitor_(NULL),
+      is_in_size_move_(false) {
+  is_window_ = true;
+  // Initialize these values to 0 so that subclasses can override the default
+  // behavior before calling Init.
+  set_window_style(0);
+  set_window_ex_style(0);
+}
+
+
+
 WindowWin::~WindowWin() {
 }
 
 void WindowWin::Show(int show_state) {
   ShowWindow(show_state);
   // When launched from certain programs like bash and Windows Live Messenger,
   // show_state is set to SW_HIDE, so we need to correct that condition. We
   // don't just change show_state to SW_SHOWNORMAL because MSDN says we must
   // always first call ShowWindow with the specified value from STARTUPINFO,
   // otherwise all future ShowWindow calls will be ignored (!!#@@#!). Instead,
@@ skipping 30 matching lines @@
   NONCLIENTMETRICS ncm;
   base::win::GetNonClientMetrics(&ncm);
   l10n_util::AdjustUIFont(&(ncm.lfCaptionFont));
   base::win::ScopedHFONT caption_font(CreateFontIndirect(&(ncm.lfCaptionFont)));
   return gfx::Font(caption_font);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowWin, protected:
 
-WindowWin::WindowWin()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)),
-      focus_on_creation_(true),
-      restored_enabled_(false),
-      fullscreen_(false),
-      is_active_(false),
-      lock_updates_(false),
-      saved_window_style_(0),
-      ignore_window_pos_changes_(false),
-      ignore_pos_changes_factory_(this),
-      force_hidden_count_(0),
-      is_right_mouse_pressed_on_caption_(false),
-      last_monitor_(NULL),
-      is_in_size_move_(false) {
-  SetNativeWindow(this);
-  is_window_ = true;
-  // Initialize these values to 0 so that subclasses can override the default
-  // behavior before calling Init.
-  set_window_style(0);
-  set_window_ex_style(0);
-}
-
 gfx::Insets WindowWin::GetClientAreaInsets() const {
   // Returning an empty Insets object causes the default handling in
   // WidgetWin::OnNCCalcSize() to be invoked.
   if (delegate_->IsUsingNativeFrame())
     return gfx::Insets();
 
   if (IsMaximized()) {
     // Windows automatically adds a standard width border to all sides when a
     // window is maximized.
     int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME);
@@ skipping 46 matching lines @@
 
 LRESULT WindowWin::OnAppCommand(HWND window, short app_command, WORD device,
                                 int keystate) {
   // We treat APPCOMMAND ids as an extension of our command namespace, and just
   // let the delegate figure out what to do...
   return GetWindow()->window_delegate()->ExecuteWindowsCommand(app_command) ||
       WidgetWin::OnAppCommand(window, app_command, device, keystate);
 }
 
 void WindowWin::OnClose() {
-  GetWindow()->CloseWindow();
+  GetWindow()->Close();
 }
 
 void WindowWin::OnCommand(UINT notification_code, int command_id, HWND window) {
   // If the notification code is > 1 it means it is control specific and we
   // should ignore it.
   if (notification_code > 1 ||
       GetWindow()->window_delegate()->ExecuteWindowsCommand(command_id)) {
     WidgetWin::OnCommand(notification_code, command_id, window);
   }
 }
@@ skipping 20 matching lines @@
   is_in_size_move_ = true;
   WidgetWin::OnEnterSizeMove();
   delegate_->OnNativeWindowBeginUserBoundsChange();
 }
 
 void WindowWin::OnExitSizeMove() {
   is_in_size_move_ = false;
   WidgetWin::OnExitSizeMove();
   delegate_->OnNativeWindowEndUserBoundsChange();
 
-  if (!GetThemeProvider()->ShouldUseNativeFrame()) {
+  if (!ShouldUseNativeFrame()) {
     // Sending SWP_FRAMECHANGED forces a non-client repaint, which fixes the
     // glitch in rendering the bottom pixel of the window caused by us
     // offsetting the client rect there (See comment in GetClientAreaInsets()).
     SetWindowPos(NULL, 0, 0, 0, 0,
                  SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER);
   }
 }
 
 void WindowWin::OnFinalMessage(HWND window) {
   delegate_->OnNativeWindowDestroyed();
@@ skipping 340 matching lines @@
 
   // Handle SC_KEYMENU, which means that the user has pressed the ALT
   // key and released it, so we should focus the menu bar.
   if ((notification_code & sc_mask) == SC_KEYMENU && click.x == 0) {
     // Retrieve the status of shift and control keys to prevent consuming
     // shift+alt keys, which are used by Windows to change input languages.
     Accelerator accelerator(ui::KeyboardCodeForWindowsKeyCode(VK_MENU),
                             !!(GetKeyState(VK_SHIFT) & 0x8000),
                             !!(GetKeyState(VK_CONTROL) & 0x8000),
                             false);
-    GetFocusManager()->ProcessAccelerator(accelerator);
+    AsNativeWidget()->GetWidget()->GetFocusManager()->
+        ProcessAccelerator(accelerator);
     return;
   }
 
   // If the delegate can't handle it, the system implementation will be called.
   if (!delegate_->ExecuteCommand(notification_code)) {
     DefWindowProc(GetNativeView(), WM_SYSCOMMAND, notification_code,
                   MAKELPARAM(click.x, click.y));
   }
 }
 
@@ skipping 98 matching lines @@
   } else {
     // The window does not get keyboard messages unless we focus it, not sure
     // why.
     SetFocus(GetNativeView());
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowWin, NativeWindow implementation:
 
+Window* WindowWin::GetWindow() {
+  return delegate_->AsWindow();
+}
+
+const Window* WindowWin::GetWindow() const {
+  return delegate_->AsWindow();
+}
+
 NativeWidget* WindowWin::AsNativeWidget() {
   return this;
 }
 
 const NativeWidget* WindowWin::AsNativeWidget() const {
   return this;
 }
 
 gfx::Rect WindowWin::GetRestoredBounds() const {
   // If we're in fullscreen mode, we've changed the normal bounds to the monitor
@@ skipping 251 matching lines @@
 
 bool WindowWin::IsFullscreen() const {
   return fullscreen_;
 }
 
 void WindowWin::SetAlwaysOnTop(bool always_on_top) {
   ::SetWindowPos(GetNativeView(), always_on_top ? HWND_TOPMOST : HWND_NOTOPMOST,
                  0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
 }
 
-bool WindowWin::IsAppWindow() const {
-  return false;
-}
-
 void WindowWin::SetUseDragFrame(bool use_drag_frame) {
   if (use_drag_frame) {
     // Make the frame slightly transparent during the drag operation.
     drag_frame_saved_window_style_ = GetWindowLong(GWL_STYLE);
     drag_frame_saved_window_ex_style_ = GetWindowLong(GWL_EXSTYLE);
     SetWindowLong(GWL_EXSTYLE,
                   drag_frame_saved_window_ex_style_ | WS_EX_LAYERED);
     // Remove the captions tyle so the window doesn't have window controls for a
     // more "transparent" look.
     SetWindowLong(GWL_STYLE, drag_frame_saved_window_style_ & ~WS_CAPTION);
     SetLayeredWindowAttributes(GetNativeWindow(), RGB(0xFF, 0xFF, 0xFF),
                                kDragFrameWindowAlpha, LWA_ALPHA);
   } else {
     SetWindowLong(GWL_STYLE, drag_frame_saved_window_style_);
     SetWindowLong(GWL_EXSTYLE, drag_frame_saved_window_ex_style_);
   }
 }
 
 NonClientFrameView* WindowWin::CreateFrameViewForWindow() {
   if (ShouldUseNativeFrame())
-    return new NativeFrameView(this);
-  return new CustomFrameView(this);
+    return new NativeFrameView(GetWindow());
+  return new CustomFrameView(GetWindow());
 }
 
 void WindowWin::UpdateFrameAfterFrameChange() {
   // We've either gained or lost a custom window region, so reset it now.
   ResetWindowRegion(true);
 }
 
 gfx::NativeWindow WindowWin::GetNativeWindow() const {
   return GetNativeView();
 }
 
 bool WindowWin::ShouldUseNativeFrame() const {
-  ui::ThemeProvider* tp = GetThemeProvider();
-  if (!tp)
-    return WidgetWin::IsAeroGlassEnabled();
-  return tp->ShouldUseNativeFrame();
+  return WidgetWin::IsAeroGlassEnabled();
 }
 
 void WindowWin::FrameTypeChanged() {
   // Called when the frame type could possibly be changing (theme change or
   // DWM composition change).
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // We need to toggle the rendering policy of the DWM/glass frame as we
     // change from opaque to glass. "Non client rendering enabled" means that
     // the DWM's glass non-client rendering is enabled, which is why
     // DWMNCRP_ENABLED is used for the native frame case. _DISABLED means the
@@ skipping 119 matching lines @@
   // it from doing so.
   ScopedRedrawLock lock(this);
   return DefWindowProc(GetNativeView(), WM_NCACTIVATE, active, 0);
 }
 
 void WindowWin::ExecuteSystemMenuCommand(int command) {
   if (command)
     SendMessage(GetNativeView(), WM_SYSCOMMAND, command, 0);
 }
 
-namespace {
-BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
-  NativeWidget* native_widget =
-      NativeWidget::GetNativeWidgetForNativeView(hwnd);
-  if (native_widget)
-    Window::CloseSecondaryWidget(native_widget->GetWidget());
-  return TRUE;
-}
-}  // namespace
-
-void Window::CloseAllSecondaryWindows() {
-  EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWindow, public:
 
 // static
-Window* NativeWindow::CreateNativeWindow() {
-  return new WindowWin;
+NativeWindow* NativeWindow::CreateNativeWindow(
+    internal::NativeWindowDelegate* delegate) {
+  return new WindowWin(delegate);
 }
 
 }  // namespace views