| OLD | NEW |
|---|
| (Empty) |
| 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 ¤t_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(¤t_infobar_dimensions)))) | |
| 484 .Times(testing::AnyNumber()).WillRepeatedly(testing::DoAll( | |
| 485 testing::SaveArg<0>(¤t_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(¤t_infobar_dimensions)))) | |
| 493 .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll( | |
| 494 testing::SaveArg<0>(¤t_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(¤t_infobar_dimensions)))) | |
| 501 .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll( | |
| 502 testing::SaveArg<0>(¤t_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>(¤t_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(¤t_infobar_dimensions)))) | |
| 518 .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll( | |
| 519 testing::SaveArg<0>(¤t_infobar_dimensions), | |
| 520 CheckSetFlag(&pending_reserve_space))); | |
| 521 EXPECT_CALL(*content, SetDimensions(testing::AllOf( | |
| 522 RectIsTopXToYOfRectZ(0, infobar_height / 2, &natural_dimensions), | |
| 523 RectHeightIsLTEToRectXHeight(¤t_infobar_dimensions)))) | |
| 524 .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll( | |
| 525 testing::SaveArg<0>(¤t_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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src