[Win Aero] Correctly set the minimum window size.

chrome/browser/apps/app_window_interactive_uitest.cc

 // Copyright 2013 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 "apps/ui/native_app_window.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/test/base/interactive_test_utils.h"
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include "base/mac/mac_util.h"
 #endif
 
+#if defined(OS_WIN)
+#include <windows.h>
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
+#include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
+#include "ui/views/win/hwnd_message_handler_delegate.h"
+#include "ui/views/win/hwnd_util.h"
+#endif
+
 using apps::NativeAppWindow;
 
 // Helper class that has to be created in the stack to check if the fullscreen
 // setting of a NativeWindow has changed since the creation of the object.
 class FullscreenChangeWaiter {
  public:
   explicit FullscreenChangeWaiter(NativeAppWindow* window)
       : window_(window),
         initial_fullscreen_state_(window_->IsFullscreen()) {}
 
@@ skipping 287 matching lines @@
 
   ASSERT_TRUE(second_key_listener.WaitUntilSatisfied());
 
   // We assume that at that point, if we had to leave fullscreen, we should be.
   // However, by nature, we can not guarantee that and given that we do test
   // that nothing happens, we might end up with random-success when the feature
   // is broken.
   EXPECT_TRUE(GetFirstAppWindow()->GetBaseWindow()->IsFullscreen());
 }
 
+IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, TestInnerBounds) {
+  ASSERT_TRUE(RunAppWindowInteractiveTest("testInnerBounds")) << message_;
+}
+
+// TODO(jackhou): Make this test work for other OSes.
+#if !defined(OS_WIN)
+#define MAYBE_TestOuterBounds DISABLED_TestOuterBounds
+#else
+#define MAYBE_TestOuterBounds TestOuterBounds
+#endif
+
+// Test that the outer bounds match that of the native window.
+IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, MAYBE_TestOuterBounds) {
+  ExtensionTestMessageListener launched_listener("Launched", true);

[benwells, 2014/08/12 03:51:40]

Nit: You don't need this listener. Just call LoadAndLaunchPlatformApp with
"Launched" instead of &launched_listener.

[jackhou1, 2014/08/12 06:12:07]

Done.

+  const extensions::Extension* app =
+      LoadAndLaunchPlatformApp("outer_bounds", &launched_listener);
+
+  apps::AppWindow* window = GetFirstAppWindowForApp(app->id());
+  gfx::Rect window_bounds;
+  gfx::Size min_size, max_size;
+
+#if defined(OS_WIN)
+  // Get the bounds from the HWND.
+  HWND hwnd = views::HWNDForNativeWindow(window->GetNativeWindow());
+  RECT rect;
+  ::GetWindowRect(hwnd, &rect);
+  window_bounds = gfx::Rect(
+      rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
+
+  // HWNDMessageHandler calls this when responding to WM_GETMINMAXSIZE, so it's
+  // the closest to what the window will see.
+  views::HWNDMessageHandlerDelegate* host =
+      static_cast<views::HWNDMessageHandlerDelegate*>(
+          static_cast<views::DesktopWindowTreeHostWin*>(
+              aura::WindowTreeHost::GetForAcceleratedWidget(hwnd)));
+  host->GetMinMaxSize(&min_size, &max_size);
+  // Note that this does not include the the client area insets so we need to
+  // add them.
+  gfx::Insets insets;
+  host->GetClientAreaInsets(&insets);
+  min_size = gfx::Size(min_size.width() + insets.left() + insets.right(),
+                       min_size.height() + insets.top() + insets.bottom());
+  max_size = gfx::Size(
+      max_size.width() ? max_size.width() + insets.left() + insets.right() : 0,
+      max_size.height() ? max_size.height() + insets.top() + insets.bottom()
+                        : 0);
+#endif  // defined(OS_WIN)
+
+  // These match the values in the outer_bounds/test.js
+  EXPECT_EQ(gfx::Rect(10, 11, 300, 301), window_bounds);
+  EXPECT_EQ(window->GetBaseWindow()->GetBounds(), window_bounds);
+  EXPECT_EQ(200, min_size.width());
+  EXPECT_EQ(201, min_size.height());
+  EXPECT_EQ(400, max_size.width());
+  EXPECT_EQ(401, max_size.height());
+}
+
 // This test does not work on Linux Aura because ShowInactive() is not
 // implemented. See http://crbug.com/325142
 // It also does not work on Windows because of the document being focused even
 // though the window is not activated. See http://crbug.com/326986
 // It also does not work on MacOS because ::ShowInactive() ends up behaving like
 // ::Show() because of Cocoa conventions. See http://crbug.com/326987
 // Those tests should be disabled on Linux GTK when they are enabled on the
 // other platforms, see http://crbug.com/328829
 #if (defined(OS_LINUX) && defined(USE_AURA)) || \
     defined(OS_WIN) || defined(OS_MACOSX)
 #define MAYBE_TestCreate DISABLED_TestCreate
 #define MAYBE_TestShow DISABLED_TestShow
 #else
 #define MAYBE_TestCreate TestCreate
 #define MAYBE_TestShow TestShow
 #endif
 
 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, MAYBE_TestCreate) {
   ASSERT_TRUE(RunAppWindowInteractiveTest("testCreate")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(AppWindowInteractiveTest, MAYBE_TestShow) {
   ASSERT_TRUE(RunAppWindowInteractiveTest("testShow")) << message_;
 }