Use WS_POPUP for ash_unittests

ui/aura/root_window_host_win.cc

 // Copyright (c) 2012 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 "ui/aura/root_window_host_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
 #include "base/message_loop.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/cursor/cursor_loader_win.h"
 #include "ui/base/events/event.h"
 #include "ui/base/view_prop.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/screen.h"
 
 using std::max;
 using std::min;
 
 namespace aura {
+namespace {
+
+bool use_popup_as_root_window_for_test = false;
+
+}  // namespace
 
 // static
 RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
   return new RootWindowHostWin(bounds);
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   return gfx::Size(GetSystemMetrics(SM_CXSCREEN),
                    GetSystemMetrics(SM_CYSCREEN));
 }
 
 RootWindowHostWin::RootWindowHostWin(const gfx::Rect& bounds)
     : delegate_(NULL),
       fullscreen_(false),
       has_capture_(false),
       saved_window_style_(0),
       saved_window_ex_style_(0) {
+  if (use_popup_as_root_window_for_test)
+    set_window_style(WS_POPUP);
   Init(NULL, bounds);
   SetWindowText(hwnd(), L"aura::RootWindow!");
 }
 
 RootWindowHostWin::~RootWindowHostWin() {
   DestroyWindow(hwnd());
 }
 
 void RootWindowHostWin::SetDelegate(RootWindowHostDelegate* delegate) {
   delegate_ = delegate;
@@ skipping 64 matching lines @@
   window_rect.top = bounds.y();
   window_rect.right = bounds.right() ;
   window_rect.bottom = bounds.bottom();
   AdjustWindowRectEx(&window_rect,
                      GetWindowLong(hwnd(), GWL_STYLE),
                      FALSE,
                      GetWindowLong(hwnd(), GWL_EXSTYLE));
   SetWindowPos(
       hwnd(),
       NULL,
-      0,
-      0,
+      window_rect.left,
+      window_rect.top,
       window_rect.right - window_rect.left,
       window_rect.bottom - window_rect.top,
       SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREDRAW | SWP_NOREPOSITION);
+
+  // Explicity call OnHostResized when the scale has changed because
+  // the window size may not have changed.
+  float current_scale = delegate_->GetDeviceScaleFactor();
+  float new_scale = gfx::Screen::GetScreenFor(delegate_->AsRootWindow())->
+      GetDisplayNearestWindow(delegate_->AsRootWindow()).device_scale_factor();
+  if (current_scale != new_scale)
+    delegate_->OnHostResized(bounds.size());
 }
 
 gfx::Point RootWindowHostWin::GetLocationOnNativeScreen() const {
   RECT r;
   GetClientRect(hwnd(), &r);
   return gfx::Point(r.left, r.top);
 }
 
 
 void RootWindowHostWin::SetCursor(gfx::NativeCursor native_cursor) {
@@ skipping 135 matching lines @@
   ValidateRect(hwnd(), NULL);
 }
 
 void RootWindowHostWin::OnSize(UINT param, const CSize& size) {
   // Minimizing resizes the window to 0x0 which causes our layout to go all
   // screwy, so we just ignore it.
   if (param != SIZE_MINIMIZED)
     delegate_->OnHostResized(gfx::Size(size.cx, size.cy));
 }
 
+namespace test {
+
+// static
+void SetUsePopupAsRootWindowForTest(bool use) {
+  use_popup_as_root_window_for_test = use;
+}
+
+}  // namespace test
+
 }  // namespace aura