chrome_frame/test/infobar_unittests.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <atlbase.h>
   6 #include <atlapp.h>
   7 #include <atlcrack.h>
   8 #include <atlmisc.h>
   9 #include <atlwin.h>
  10
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "chrome_frame/infobars/infobar_content.h"
  15 #include "chrome_frame/infobars/internal/displaced_window_manager.h"
  16 #include "chrome_frame/infobars/internal/host_window_manager.h"
  17 #include "chrome_frame/infobars/internal/infobar_window.h"
  18 #include "chrome_frame/infobars/internal/subclassing_window_with_delegate.h"
  19 #include "chrome_frame/test/chrome_frame_test_utils.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 namespace {
  24
  25 RECT kInitialParentWindowRect = {20, 20, 300, 300};
  26 RECT kInitialChildWindowRect = {20, 20, 280, 280};
  27
  28 MATCHER_P(EqualRect, expected, "") {
  29   return ::EqualRect(expected, arg);
  30 }
  31
  32 ACTION_P2(RespondToNcCalcSize, result, rect) {
  33   *reinterpret_cast<RECT*>(arg1) = *rect;
  34   return result;
  35 }
  36
  37 ACTION_P4(RespondToNcCalcSize, result, rect1, rect2, rect3) {
  38   reinterpret_cast<RECT*>(arg1)[0] = rect1;
  39   reinterpret_cast<RECT*>(arg1)[1] = rect2;
  40   reinterpret_cast<RECT*>(arg1)[2] = rect3;
  41   return result;
  42 }
  43
  44 class ParentTraits : public CFrameWinTraits {
  45  public:
  46   static const wchar_t* kClassName;
  47 };  // class ParentTraits
  48
  49 class ChildTraits : public CControlWinTraits {
  50  public:
  51   static const wchar_t* kClassName;
  52 };  // class ChildTraits
  53
  54 const wchar_t* ParentTraits::kClassName = NULL;
  55 const wchar_t* ChildTraits::kClassName = L"Shell DocObject View";
  56
  57 template<typename TRAITS> class MockWindow
  58     : public CWindowImpl<MockWindow<TRAITS>, CWindow, TRAITS> {
  59  public:
  60   virtual ~MockWindow() {
  61     if (IsWindow())
  62       DestroyWindow();
  63   }
  64   MOCK_METHOD1(OnCreate, int(LPCREATESTRUCT lpCreateStruct));
  65   MOCK_METHOD0(OnDestroy, void());
  66   MOCK_METHOD2(OnSize, void(UINT nType, CSize size));
  67   MOCK_METHOD1(OnMove, void(CPoint ptPos));
  68   MOCK_METHOD2(OnNcCalcSize, LRESULT(BOOL bCalcValidRects, LPARAM lParam));
  69   DECLARE_WND_CLASS(TRAITS::kClassName);
  70   BEGIN_MSG_MAP_EX(MockWindow)
  71     MSG_WM_CREATE(OnCreate)
  72     MSG_WM_DESTROY(OnDestroy)
  73     MSG_WM_SIZE(OnSize)
  74     MSG_WM_MOVE(OnMove)
  75     MSG_WM_NCCALCSIZE(OnNcCalcSize)
  76   END_MSG_MAP()
  77 };  // class MockWindow
  78
  79 typedef MockWindow<ParentTraits> MockTopLevelWindow;
  80 typedef MockWindow<ChildTraits> MockChildWindow;
  81
  82 class MockWindowSubclass
  83     : public SubclassingWindowWithDelegate<MockWindowSubclass> {
  84  public:
  85   MOCK_METHOD2(OnNcCalcSize, LRESULT(BOOL bCalcValidRects, LPARAM lParam));
  86   BEGIN_MSG_MAP_EX(MockWindowSubclass)
  87     MSG_WM_NCCALCSIZE(OnNcCalcSize)
  88     CHAIN_MSG_MAP(SubclassingWindowWithDelegate<MockWindowSubclass>)
  89   END_MSG_MAP()
  90   virtual ~MockWindowSubclass() { Die(); }
  91   MOCK_METHOD0(Die, void());
  92 };  // class MockWindowSubclass
  93
  94 template<typename T> class MockDelegate
  95     : public SubclassingWindowWithDelegate<T>::Delegate {
  96  public:
  97   virtual ~MockDelegate() { Die(); }
  98   MOCK_METHOD0(Die, void());
  99   MOCK_METHOD1(AdjustDisplacedWindowDimensions, void(RECT* rect));
 100 };  // clas MockDelegate
 101
 102 template<typename T> T* Initialize(T* t,
 103                                    HWND hwnd,
 104                                    typename T::Delegate* delegate) {
 105   if (t->Initialize(hwnd, delegate)) {
 106     return t;
 107   } else {
 108     delete t;
 109     return NULL;
 110   }
 111 }
 112
 113 };  // namespace
 114
 115 TEST(InfobarsSubclassingWindowWithDelegateTest, BasicTest) {
 116   testing::NiceMock<MockTopLevelWindow> window;
 117   ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
 118
 119   HWND hwnd = static_cast<HWND>(window);
 120
 121   ASSERT_TRUE(MockWindowSubclass::GetDelegateForHwnd(hwnd) == NULL);
 122
 123   MockDelegate<MockWindowSubclass>* delegate =
 124       new testing::StrictMock<MockDelegate<MockWindowSubclass> >();
 125   MockWindowSubclass* swwd = Initialize(
 126       new testing::StrictMock<MockWindowSubclass>(), hwnd, delegate);
 127   ASSERT_TRUE(swwd != NULL);
 128   ASSERT_EQ(static_cast<MockWindowSubclass::Delegate*>(delegate),
 129             MockWindowSubclass::GetDelegateForHwnd(hwnd));
 130
 131   // Since expectations are only validated upon object destruction, this test
 132   // would normally pass even if the expected deletions never happened.
 133   // By expecting another call, in sequence, after the deletions, we force a
 134   // failure if those deletions don't occur.
 135   testing::MockFunction<void(std::string check_point_name)> check;
 136
 137   {
 138     testing::InSequence s;
 139     EXPECT_CALL(*delegate, Die());
 140     EXPECT_CALL(*swwd, Die());
 141     EXPECT_CALL(check, Call("checkpoint"));
 142   }
 143
 144   window.DestroyWindow();
 145
 146   check.Call("checkpoint");
 147
 148   ASSERT_TRUE(MockWindowSubclass::GetDelegateForHwnd(hwnd) == NULL);
 149 }
 150
 151 TEST(InfobarsSubclassingWindowWithDelegateTest, InvalidHwndTest) {
 152   testing::NiceMock<MockTopLevelWindow> window;
 153   ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
 154
 155   HWND hwnd = static_cast<HWND>(window);
 156
 157   window.DestroyWindow();
 158
 159   MockDelegate<MockWindowSubclass>* delegate =
 160       new testing::StrictMock<MockDelegate<MockWindowSubclass> >();
 161   MockWindowSubclass* swwd = new testing::StrictMock<MockWindowSubclass>();
 162
 163   testing::MockFunction<void(std::string check_point_name)> check;
 164
 165   {
 166     testing::InSequence s;
 167     EXPECT_CALL(*delegate, Die());
 168     EXPECT_CALL(check, Call("checkpoint"));
 169     EXPECT_CALL(*swwd, Die());
 170   }
 171
 172   ASSERT_FALSE(swwd->Initialize(hwnd, delegate));
 173   check.Call("checkpoint");  // Make sure the delegate has been deleted
 174   delete swwd;
 175
 176   ASSERT_TRUE(MockWindowSubclass::GetDelegateForHwnd(hwnd) == NULL);
 177 }
 178
 179 template <typename WINDOW, typename DELEGATE> void ExpectNcCalcSizeSequence(
 180     WINDOW* mock_window,
 181     DELEGATE* delegate,
 182     RECT* natural_rect,
 183     RECT* modified_rect) {
 184   testing::InSequence s;
 185   EXPECT_CALL(*mock_window, OnNcCalcSize(true, testing::_)).WillOnce(
 186       RespondToNcCalcSize(0, natural_rect));
 187   EXPECT_CALL(*delegate,
 188               AdjustDisplacedWindowDimensions(EqualRect(natural_rect)))
 189       .WillOnce(testing::SetArgumentPointee<0>(*modified_rect));
 190   EXPECT_CALL(*mock_window, OnMove(CPoint(modified_rect->left,
 191                                           modified_rect->top)));
 192   EXPECT_CALL(*mock_window,
 193               OnSize(0, CSize(modified_rect->right - modified_rect->left,
 194                               modified_rect->bottom - modified_rect->top)));
 195
 196   EXPECT_CALL(*mock_window, OnNcCalcSize(true, testing::_))
 197     .Times(testing::Between(0, 1))
 198     .WillOnce(RespondToNcCalcSize(0, natural_rect));
 199   EXPECT_CALL(*delegate,
 200               AdjustDisplacedWindowDimensions(EqualRect(natural_rect)))
 201     .Times(testing::Between(0, 1))
 202     .WillOnce(testing::SetArgumentPointee<0>(*modified_rect));
 203   EXPECT_CALL(*mock_window, OnMove(CPoint(modified_rect->left,
 204                                           modified_rect->top)))
 205     .Times(testing::Between(0, 1));
 206   EXPECT_CALL(*mock_window,
 207               OnSize(0, CSize(modified_rect->right - modified_rect->left,
 208                               modified_rect->bottom - modified_rect->top)))
 209     .Times(testing::Between(0, 1));
 210 }
 211
 212 template <typename WINDOW, typename DELEGATE, typename MANAGER>
 213     void DoNcCalcSizeSequence(WINDOW* mock_window,
 214                               DELEGATE* delegate,
 215                               MANAGER* manager) {
 216   RECT natural_rects[] = { {0, 0, 100, 100}, {10, 10, 120, 120} };
 217   RECT modified_rects[] = { {10, 5, 90, 95}, {25, 35, 80, 70} };
 218
 219   ExpectNcCalcSizeSequence(
 220       mock_window, delegate, &natural_rects[0], &natural_rects[0]);
 221   // The first time through, trigger the sizing via the manager.
 222   // This is required for the HostWindowManager, since it only looks up
 223   // and subclasses the displaced window on demand.
 224   manager->UpdateLayout();
 225
 226   testing::Mock::VerifyAndClearExpectations(mock_window);
 227   testing::Mock::VerifyAndClearExpectations(delegate);
 228
 229   ExpectNcCalcSizeSequence(
 230       mock_window, delegate, &natural_rects[1], &natural_rects[1]);
 231   // The second time through, trigger it through the original window.
 232   // By now, we expect to be observing the window in all cases.
 233   ::SetWindowPos(static_cast<HWND>(*mock_window),
 234                  NULL, 0, 0, 0, 0,
 235                  SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
 236                  SWP_FRAMECHANGED);
 237
 238   testing::Mock::VerifyAndClearExpectations(mock_window);
 239   testing::Mock::VerifyAndClearExpectations(delegate);
 240 }
 241
 242 TEST(InfobarsDisplacedWindowManagerTest, BasicTest) {
 243   testing::NiceMock<MockTopLevelWindow> window;
 244   ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
 245
 246   MockDelegate<DisplacedWindowManager>* delegate =
 247       new testing::StrictMock<MockDelegate<DisplacedWindowManager> >();
 248
 249   DisplacedWindowManager* dwm = new DisplacedWindowManager();
 250   ASSERT_TRUE(dwm->Initialize(static_cast<HWND>(window), delegate));
 251   ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&window, delegate, dwm));
 252
 253   EXPECT_CALL(*delegate, Die());
 254   window.DestroyWindow();
 255 }
 256
 257 TEST(InfobarsHostWindowManagerTest, BasicTest) {
 258   testing::NiceMock<MockTopLevelWindow> window;
 259   ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
 260   testing::NiceMock<MockChildWindow> child_window;
 261   ASSERT_TRUE(child_window.Create(window, kInitialChildWindowRect) != NULL);
 262   testing::NiceMock<MockChildWindow> child_window2;
 263   testing::NiceMock<MockChildWindow> child_window3;
 264
 265   MockDelegate<HostWindowManager>* delegate =
 266       new testing::StrictMock<MockDelegate<HostWindowManager> >();
 267
 268   HostWindowManager* hwm = new HostWindowManager();
 269
 270   ASSERT_TRUE(hwm->Initialize(static_cast<HWND>(window), delegate));
 271   ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&child_window, delegate, hwm));
 272
 273   // First, destroy window 1 and subsequently create window 2
 274   child_window.DestroyWindow();
 275
 276   ASSERT_TRUE(child_window2.Create(window, kInitialChildWindowRect) != NULL);
 277   ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&child_window2, delegate, hwm));
 278
 279   // Next, create window 3 just before destroying window 2
 280   RECT natural_rect = {10, 15, 40, 45};
 281   RECT modified_rect = {15, 20, 35, 40};
 282
 283   ASSERT_TRUE(child_window3.Create(window, kInitialChildWindowRect) != NULL);
 284   ExpectNcCalcSizeSequence(
 285       &child_window3, delegate, &natural_rect, &natural_rect);
 286   child_window2.DestroyWindow();
 287
 288   ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&child_window3, delegate, hwm));
 289
 290   EXPECT_CALL(*delegate, Die());
 291   window.DestroyWindow();
 292 }
 293
 294 // Must be declared in same namespace as RECT
 295 void PrintTo(const RECT& rect, ::std::ostream* os) {
 296   *os << "{" << rect.left << ", " << rect.top << ", " << rect.right << ", "
 297       << rect.bottom << "}";
 298 }
 299
 300 namespace {
 301
 302 class MockHost : public InfobarWindow::Host {
 303  public:
 304   MockHost(InfobarWindow* infobar_window,
 305            const RECT& natural_dimensions,
 306            HWND hwnd)
 307       : infobar_window_(infobar_window),
 308         natural_dimensions_(natural_dimensions),
 309         hwnd_(hwnd) {
 310   }
 311
 312   void SetNaturalDimensions(const RECT& natural_dimensions) {
 313     natural_dimensions_ = natural_dimensions;
 314     UpdateLayout();
 315   }
 316
 317   virtual HWND GetContainerWindow() {
 318     return hwnd_;
 319   }
 320
 321   virtual void UpdateLayout() {
 322     RECT temp(natural_dimensions_);
 323     infobar_window_->ReserveSpace(&temp);
 324     CheckReservedSpace(&temp);
 325   }
 326
 327   MOCK_METHOD0(Die, void(void));
 328
 329   // Convenience method for checking the result of InfobarWindow::ReserveSpace
 330   MOCK_METHOD1(CheckReservedSpace, void(RECT* rect));
 331
 332  private:
 333   InfobarWindow* infobar_window_;
 334   RECT natural_dimensions_;
 335   HWND hwnd_;
 336 };  // class MockHost
 337
 338 class MockInfobarContent : public InfobarContent {
 339  public:
 340   virtual ~MockInfobarContent() { Die(); }
 341
 342   MOCK_METHOD1(InstallInFrame,  bool(Frame* frame));
 343   MOCK_METHOD1(SetDimensions, void(const RECT& dimensions));
 344   MOCK_METHOD2(GetDesiredSize, size_t(size_t width, size_t height));
 345   MOCK_METHOD0(Die, void(void));
 346 };  // class MockInfobarContent
 347
 348 MATCHER_P(
 349     RectHeightIsLTEToRectXHeight, rect_x, "height is <= to height of rect x") {
 350   return arg.bottom - arg.top <= rect_x->bottom - rect_x->top;
 351 }
 352
 353 MATCHER_P(
 354     RectHeightIsGTEToRectXHeight, rect_x, "height is >= to height of rect x") {
 355   return arg.bottom - arg.top >= rect_x->bottom - rect_x->top;
 356 }
 357
 358 MATCHER_P3(RectIsTopXToYOfRectZ, x, y, rect_z, "is top x to y of rect z" ) {
 359   return rect_z->top == arg.top &&
 360       rect_z->left == arg.left &&
 361       rect_z->right == arg.right &&
 362       arg.bottom - arg.top >= x &&
 363       arg.bottom - arg.top <= y;
 364 }
 365
 366 MATCHER_P2(RectAddedToRectXMakesRectY,
 367            rect_x,
 368            rect_y,
 369            "rect added to rect x makes rect y") {
 370   if (::IsRectEmpty(rect_x))
 371     return ::EqualRect(arg, rect_y);
 372
 373   if (::IsRectEmpty(arg))
 374     return ::EqualRect(rect_x, rect_y);
 375
 376   // Either they are left and right slices, or top and bottom slices
 377   if (!((rect_x->left == rect_y->left && rect_x->right == rect_y->right &&
 378          arg->left == rect_y->left && arg->right == rect_y->right) ||
 379         (rect_x->top == rect_y->top && rect_x->bottom== rect_y->bottom &&
 380          arg->top == rect_y->top && arg->bottom == rect_y->bottom))) {
 381     return false;
 382   }
 383
 384   RECT expected_arg;
 385
 386   if (!::SubtractRect(&expected_arg, rect_y, rect_x))
 387     return false;  // Given above checks, the difference should not be empty
 388
 389   return ::EqualRect(arg, &expected_arg);
 390 }
 391
 392 MATCHER_P(FrameHwndIs, hwnd, "") {
 393   return arg != NULL && arg->GetFrameWindow() == hwnd;
 394 }
 395
 396 ACTION_P(CheckSetFlag, flag) {
 397   ASSERT_FALSE(*flag);
 398   *flag = true;
 399 }
 400
 401 ACTION_P(ResetFlag, flag) {
 402   *flag = false;
 403 }
 404
 405 ACTION_P2(AsynchronousCloseOnFrame, loop, frame) {
 406   loop->PostTask(FROM_HERE, base::Bind(&InfobarContent::Frame::CloseInfobar,
 407                                        base::Unretained(*frame)));
 408 }
 409
 410 ACTION_P2(AsynchronousHideOnManager, loop, manager) {
 411   loop->PostTask(FROM_HERE, base::Bind(&InfobarManager::Hide,
 412                                        base::Unretained(manager), TOP_INFOBAR));
 413 }
 414
 415 };  // namespace
 416
 417 // The test ensures that the content is sized at least once in each of the
 418 // following ranges while fully opening and closing:
 419 //
 420 // [0, infobar_height / 2)
 421 // [infobar_height / 2, infobar_height)
 422 // [infobar_height, infobar_height]
 423 // (infobar_height / 2, infobar_height]
 424 // [0, infobar_height / 2]
 425 //
 426 // If the test turns out to be flaky (i.e., because timers are not firing
 427 // frequently enough to hit all the ranges), increasing the infobar_height
 428 // should increase the margin (by increasing the time spent in each range).
 429 TEST(InfobarsInfobarWindowTest, SlidingTest) {
 430   int infobar_height = 40;
 431
 432   chrome_frame_test::TimedMsgLoop message_loop;
 433
 434   RECT natural_dimensions = {10, 20, 90, 100 + infobar_height};
 435
 436   // Used to verify that the last RECT given to SetDimensions is the same RECT
 437   // reserved by ReserveSpace.
 438   RECT current_infobar_dimensions = {0, 0, 0, 0};
 439
 440   // Used to make sure that each SetDimensions is matched by a return from
 441   // ReserveSpace.
 442   bool pending_reserve_space = false;
 443
 444   InfobarWindow infobar_window(TOP_INFOBAR);
 445
 446   testing::NiceMock<MockTopLevelWindow> window;
 447   ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect));
 448   HWND hwnd = static_cast<HWND>(window);
 449   MockInfobarContent* content = new MockInfobarContent();
 450   scoped_ptr<MockHost> host(new MockHost(&infobar_window,
 451                                          natural_dimensions,
 452                                          hwnd));
 453
 454   infobar_window.SetHost(host.get());
 455
 456   // Used to ensure that GetDesiredSize is only called on an installed
 457   // InfobarContent.
 458   testing::Expectation installed;
 459
 460   // Will hold the frame given to us in InfobarContent::InstallInFrame.
 461   InfobarContent::Frame* frame = NULL;
 462
 463   // We could get any number of calls to UpdateLayout. Make sure that, each
 464   // time, the space reserved by the InfobarWindow equals the space offered to
 465   // the InfobarContent.
 466   EXPECT_CALL(*host, CheckReservedSpace(RectAddedToRectXMakesRectY(
 467       &current_infobar_dimensions, &natural_dimensions)))
 468       .Times(testing::AnyNumber())
 469       .WillRepeatedly(ResetFlag(&pending_reserve_space));
 470
 471   testing::MockFunction<void(std::string check_point_name)> check;
 472
 473   {
 474     testing::InSequence s;
 475     // During Show(), we get an InstallInFrame
 476     installed = EXPECT_CALL(*content, InstallInFrame(FrameHwndIs(hwnd)))
 477         .WillOnce(testing::DoAll(testing::SaveArg<0>(&frame),
 478                                  testing::Return(true)));
 479
 480     // Allow a call to SetDimensions before InstallInFrame returns.
 481     EXPECT_CALL(*content, SetDimensions(testing::AllOf(
 482         RectIsTopXToYOfRectZ(0, infobar_height / 2 - 1, &natural_dimensions),
 483         RectHeightIsGTEToRectXHeight(&current_infobar_dimensions))))
 484         .Times(testing::AnyNumber()).WillRepeatedly(testing::DoAll(
 485             testing::SaveArg<0>(&current_infobar_dimensions),
 486             CheckSetFlag(&pending_reserve_space)));
 487
 488     EXPECT_CALL(check, Call("returned from Show"));
 489
 490     EXPECT_CALL(*content, SetDimensions(testing::AllOf(
 491         RectIsTopXToYOfRectZ(0, infobar_height / 2 - 1, &natural_dimensions),
 492         RectHeightIsGTEToRectXHeight(&current_infobar_dimensions))))
 493         .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
 494             testing::SaveArg<0>(&current_infobar_dimensions),
 495             CheckSetFlag(&pending_reserve_space)));
 496     EXPECT_CALL(*content, SetDimensions(testing::AllOf(
 497         RectIsTopXToYOfRectZ(infobar_height / 2,
 498                              infobar_height - 1,
 499                              &natural_dimensions),
 500         RectHeightIsGTEToRectXHeight(&current_infobar_dimensions))))
 501         .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
 502             testing::SaveArg<0>(&current_infobar_dimensions),
 503             CheckSetFlag(&pending_reserve_space)));
 504     EXPECT_CALL(*content, SetDimensions(
 505         RectIsTopXToYOfRectZ(infobar_height,
 506                              infobar_height,
 507                              &natural_dimensions)))
 508         .WillOnce(testing::DoAll(
 509             testing::SaveArg<0>(&current_infobar_dimensions),
 510             CheckSetFlag(&pending_reserve_space),
 511             AsynchronousCloseOnFrame(&message_loop, &frame)));
 512
 513     EXPECT_CALL(*content, SetDimensions(testing::AllOf(
 514         RectIsTopXToYOfRectZ(infobar_height / 2 + 1,
 515                              infobar_height,
 516                              &natural_dimensions),
 517         RectHeightIsLTEToRectXHeight(&current_infobar_dimensions))))
 518         .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
 519             testing::SaveArg<0>(&current_infobar_dimensions),
 520             CheckSetFlag(&pending_reserve_space)));
 521     EXPECT_CALL(*content, SetDimensions(testing::AllOf(
 522         RectIsTopXToYOfRectZ(0, infobar_height / 2, &natural_dimensions),
 523         RectHeightIsLTEToRectXHeight(&current_infobar_dimensions))))
 524         .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
 525             testing::SaveArg<0>(&current_infobar_dimensions),
 526             CheckSetFlag(&pending_reserve_space)));
 527
 528     EXPECT_CALL(*content, Die()).WillOnce(QUIT_LOOP(message_loop));
 529   }
 530
 531   EXPECT_CALL(*content, GetDesiredSize(80, 0))
 532       .Times(testing::AnyNumber()).After(installed)
 533       .WillRepeatedly(testing::Return(infobar_height));
 534
 535   ASSERT_NO_FATAL_FAILURE(infobar_window.Show(content));
 536
 537   ASSERT_NO_FATAL_FAILURE(check.Call("returned from Show"));
 538
 539   ASSERT_NO_FATAL_FAILURE(message_loop.RunFor(
 540       base::TimeDelta::FromSeconds(10)));
 541
 542   window.DestroyWindow();
 543
 544   ASSERT_FALSE(message_loop.WasTimedOut());
 545 }
 546
 547 TEST(InfobarsInfobarManagerTest, BasicTest) {
 548   chrome_frame_test::TimedMsgLoop message_loop;
 549
 550   int infobar_height = 40;
 551   RECT natural_dimensions = {10, 20, 90, 100 + infobar_height};
 552
 553   testing::NiceMock<MockTopLevelWindow> window;
 554   ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
 555   testing::NiceMock<MockChildWindow> child_window;
 556   ASSERT_TRUE(child_window.Create(window, kInitialChildWindowRect) != NULL);
 557
 558   HWND parent_hwnd = static_cast<HWND>(window);
 559   HWND child_hwnd = static_cast<HWND>(child_window);
 560
 561   MockInfobarContent* content = new MockInfobarContent();
 562   InfobarContent::Frame* frame = NULL;
 563
 564   InfobarManager* manager = InfobarManager::Get(parent_hwnd);
 565   ASSERT_FALSE(manager == NULL);
 566
 567   EXPECT_CALL(*content, GetDesiredSize(80, 0))
 568       .Times(testing::AnyNumber())
 569       .WillRepeatedly(testing::Return(infobar_height));
 570
 571   EXPECT_CALL(child_window, OnNcCalcSize(true, testing::_))
 572       .Times(testing::AnyNumber()).WillRepeatedly(
 573           RespondToNcCalcSize(0, &natural_dimensions));
 574
 575   EXPECT_CALL(*content, InstallInFrame(FrameHwndIs(parent_hwnd)))
 576       .WillOnce(testing::DoAll(testing::SaveArg<0>(&frame),
 577                                testing::Return(true)));
 578
 579   EXPECT_CALL(*content, SetDimensions(testing::Not(
 580       RectIsTopXToYOfRectZ(infobar_height,
 581                            infobar_height,
 582                            &natural_dimensions)))).Times(testing::AnyNumber());
 583
 584   EXPECT_CALL(*content, SetDimensions(
 585       RectIsTopXToYOfRectZ(infobar_height,
 586                            infobar_height,
 587                            &natural_dimensions)))
 588       .Times(testing::AnyNumber())
 589       .WillOnce(AsynchronousHideOnManager(&message_loop, manager))
 590       .WillRepeatedly(testing::Return());
 591
 592   EXPECT_CALL(*content, Die()).WillOnce(QUIT_LOOP(message_loop));
 593
 594   ASSERT_TRUE(manager->Show(content, TOP_INFOBAR));
 595
 596   message_loop.RunFor(base::TimeDelta::FromSeconds(10));
 597
 598   window.DestroyWindow();
 599
 600   ASSERT_FALSE(message_loop.WasTimedOut());
 601 }
 602
 603 // TODO(erikwright): Write test for variations on return from default
 604 // OnNcCalcValidRects