Preview CL for adding an Infobar facility to Google Chrome Frame....

chrome_frame/test/infobar_unittests.cc

+// Copyright (c) 2010 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 <atlbase.h>
+#include <atlapp.h>
+#include <atlcrack.h>
+#include <atlmisc.h>
+#include <atlwin.h>
+
+#include "base/string_number_conversions.h"
+#include "base/win_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+#include "chrome_frame/infobars/content.h"
+#include "chrome_frame/infobars/internal/displaced_window.h"
+#include "chrome_frame/infobars/internal/host_window.h"
+#include "chrome_frame/infobars/internal/infobar_window.h"
+#include "chrome_frame/infobars/internal/subclassing_window.h"
+#include "chrome_frame/test/chrome_frame_test_utils.h"
+
+DISABLE_RUNNABLE_METHOD_REFCOUNT(InfobarContent::Frame);
+DISABLE_RUNNABLE_METHOD_REFCOUNT(InfobarManager);
+
+namespace {
+
+RECT kInitialParentWindowRect = {20, 20, 300, 300};
+RECT kInitialChildWindowRect = {20, 20, 280, 280};
+
+MATCHER_P(EqualRect, expected, "") {
+  return ::EqualRect(expected, arg);
+}
+
+ACTION_P2(RespondToNcCalcSize, result, rect) {
+  *reinterpret_cast<RECT*>(arg1) = *rect;
+  return result;
+}
+
+ACTION_P4(RespondToNcCalcSize, result, rect1, rect2, rect3) {
+  reinterpret_cast<RECT*>(arg1)[0] = rect1;
+  reinterpret_cast<RECT*>(arg1)[1] = rect2;
+  reinterpret_cast<RECT*>(arg1)[2] = rect3;
+  return result;
+}
+
+class ParentTraits : public CFrameWinTraits {
+ public:
+  static const wchar_t* kClassName;
+};  // class ParentTraits
+
+class ChildTraits : public CControlWinTraits {
+ public:
+  static const wchar_t* kClassName;
+};  // class ChildTraits
+
+const wchar_t* ParentTraits::kClassName = NULL;
+const wchar_t* ChildTraits::kClassName = L"Shell DocObject View";
+
+template<typename TRAITS> class MockWindow
+    : public CWindowImpl<MockWindow<TRAITS>, CWindow, TRAITS> {
+ public:
+  virtual ~MockWindow() {
+    if (IsWindow())
+      DestroyWindow();
+  }
+  MOCK_METHOD1(OnCreate, int(LPCREATESTRUCT lpCreateStruct));
+  MOCK_METHOD0(OnDestroy, void());
+  MOCK_METHOD2(OnSize, void(UINT nType, CSize size));
+  MOCK_METHOD1(OnMove, void(CPoint ptPos));
+  MOCK_METHOD2(OnNcCalcSize, LRESULT(BOOL bCalcValidRects, LPARAM lParam));
+  DECLARE_WND_CLASS(TRAITS::kClassName);
+  BEGIN_MSG_MAP_EX(MockWindow)
+    MSG_WM_CREATE(OnCreate)
+    MSG_WM_DESTROY(OnDestroy)
+    MSG_WM_SIZE(OnSize)
+    MSG_WM_MOVE(OnMove)
+    MSG_WM_NCCALCSIZE(OnNcCalcSize)
+  END_MSG_MAP()
+};  // class MockWindow
+
+typedef MockWindow<ParentTraits> MockTopLevelWindow;
+typedef MockWindow<ChildTraits> MockChildWindow;
+
+class MockWindowSubclass
+    : public SubclassingWindowWithDelegate<MockWindowSubclass> {
+ public:
+  MOCK_METHOD2(OnNcCalcSize, LRESULT(BOOL bCalcValidRects, LPARAM lParam));
+  BEGIN_MSG_MAP_EX(MockWindowSubclass)
+    MSG_WM_NCCALCSIZE(OnNcCalcSize)
+    CHAIN_MSG_MAP(SubclassingWindowWithDelegate<MockWindowSubclass>)
+  END_MSG_MAP()
+  virtual ~MockWindowSubclass() { Die(); }
+  MOCK_METHOD0(Die, void());
+};  // class MockWindowSubclass
+
+template<typename T> class MockDelegate
+    : public SubclassingWindowWithDelegate<T>::Delegate {
+ public:
+  virtual ~MockDelegate() { Die(); }
+  MOCK_METHOD0(Die, void());
+  MOCK_METHOD1(AdjustDisplacedWindowDimensions, void(RECT* rect));
+};  // clas MockDelegate
+
+template<typename T> T* Initialize(T* t,
+                                   HWND hwnd,
+                                   typename T::Delegate* delegate) {
+  if (t->Initialize(hwnd, delegate)) {
+    return t;
+  } else {
+    delete t;
+    return NULL;
+  }
+}
+
+};  // namespace
+
+TEST(InfobarsSubclassingWindowWithDelegateTest, BasicTest) {
+  testing::NiceMock<MockTopLevelWindow> window;
+  ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
+
+  HWND hwnd = static_cast<HWND>(window);
+
+  ASSERT_TRUE(MockWindowSubclass::GetDelegateForHwnd(hwnd) == NULL);
+
+  MockDelegate<MockWindowSubclass>* delegate =
+      new testing::StrictMock<MockDelegate<MockWindowSubclass> >();
+  MockWindowSubclass* swwd = Initialize(
+      new testing::StrictMock<MockWindowSubclass>(), hwnd, delegate);
+  ASSERT_TRUE(swwd != NULL);
+  ASSERT_EQ(static_cast<MockWindowSubclass::Delegate*>(delegate),
+            MockWindowSubclass::GetDelegateForHwnd(hwnd));
+
+  // Since expectations are only validated upon object destruction, this test
+  // would normally pass even if the expected deletions never happened.
+  // By expecting another call, in sequence, after the deletions, we force a
+  // failure if those deletions don't occur.
+  testing::MockFunction<void(std::string check_point_name)> check;
+
+  {
+    testing::InSequence s;
+    EXPECT_CALL(*delegate, Die());
+    EXPECT_CALL(*swwd, Die());
+    EXPECT_CALL(check, Call("checkpoint"));
+  }
+
+  window.DestroyWindow();
+
+  check.Call("checkpoint");
+
+  ASSERT_TRUE(MockWindowSubclass::GetDelegateForHwnd(hwnd) == NULL);
+}
+
+TEST(InfobarsSubclassingWindowWithDelegateTest, InvalidHwndTest) {
+  testing::NiceMock<MockTopLevelWindow> window;
+  ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
+
+  HWND hwnd = static_cast<HWND>(window);
+
+  window.DestroyWindow();
+
+  MockDelegate<MockWindowSubclass>* delegate =
+      new testing::StrictMock<MockDelegate<MockWindowSubclass> >();
+  MockWindowSubclass* swwd = new testing::StrictMock<MockWindowSubclass>();
+
+  testing::MockFunction<void(std::string check_point_name)> check;
+
+  {
+    testing::InSequence s;
+    EXPECT_CALL(*delegate, Die());
+    EXPECT_CALL(check, Call("checkpoint"));
+    EXPECT_CALL(*swwd, Die());
+  }
+
+  ASSERT_FALSE(swwd->Initialize(hwnd, delegate));
+  check.Call("checkpoint");  // Make sure the delegate has been deleted
+  delete swwd;
+
+  ASSERT_TRUE(MockWindowSubclass::GetDelegateForHwnd(hwnd) == NULL);
+}
+
+template <typename WINDOW, typename DELEGATE> void ExpectNcCalcSizeSequence(
+    WINDOW* mock_window,
+    DELEGATE* delegate,
+    RECT* natural_rect,
+    RECT* modified_rect) {
+  testing::InSequence s;
+  EXPECT_CALL(*mock_window, OnNcCalcSize(true, testing::_)).WillOnce(
+      RespondToNcCalcSize(0, natural_rect));
+  EXPECT_CALL(*delegate,
+              AdjustDisplacedWindowDimensions(EqualRect(natural_rect)))
+      .WillOnce(testing::SetArgumentPointee<0>(*modified_rect));
+  EXPECT_CALL(*mock_window, OnMove(CPoint(modified_rect->left,
+                                          modified_rect->top)));
+  EXPECT_CALL(*mock_window,
+              OnSize(0, CSize(modified_rect->right - modified_rect->left,
+                              modified_rect->bottom - modified_rect->top)));
+}
+
+template <typename WINDOW, typename DELEGATE, typename MANAGER>
+    void DoNcCalcSizeSequence(WINDOW* mock_window,
+                              DELEGATE* delegate,
+                              MANAGER* manager) {
+  RECT natural_rects[] = { {0, 0, 100, 100}, {10, 10, 120, 120} };
+  RECT modified_rects[] = { {10, 5, 90, 95}, {25, 35, 80, 70} };
+
+  ExpectNcCalcSizeSequence(
+      mock_window, delegate, &natural_rects[0], &natural_rects[0]);
+  // The first time through, trigger the sizing via the manager.
+  // This is required for the HostWindowManager, since it only looks up
+  // and subclasses the displaced window on demand.
+  manager->UpdateLayout();
+
+  ExpectNcCalcSizeSequence(
+      mock_window, delegate, &natural_rects[1], &natural_rects[1]);
+  // The second time through, trigger it through the original window.
+  // By now, we expect to be observing the window in all cases.
+  ::SetWindowPos(static_cast<HWND>(*mock_window),
+                 NULL, 0, 0, 0, 0,
+                 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
+                 SWP_FRAMECHANGED);
+
+  testing::Mock::VerifyAndClearExpectations(mock_window);
+  testing::Mock::VerifyAndClearExpectations(delegate);
+}
+
+TEST(InfobarsDisplacedWindowManagerTest, BasicTest) {
+  testing::NiceMock<MockTopLevelWindow> window;
+  ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
+
+  MockDelegate<DisplacedWindowManager>* delegate =
+      new testing::StrictMock<MockDelegate<DisplacedWindowManager> >();
+
+  DisplacedWindowManager* dwm = new DisplacedWindowManager();
+  ASSERT_TRUE(dwm->Initialize(static_cast<HWND>(window), delegate));
+  ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&window, delegate, dwm));
+
+  EXPECT_CALL(*delegate, Die());
+  window.DestroyWindow();
+}
+
+TEST(InfobarsHostWindowManagerTest, BasicTest) {
+  testing::NiceMock<MockTopLevelWindow> window;
+  ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
+  testing::NiceMock<MockChildWindow> child_window;
+  ASSERT_TRUE(child_window.Create(window, kInitialChildWindowRect) != NULL);
+  testing::NiceMock<MockChildWindow> child_window2;
+  testing::NiceMock<MockChildWindow> child_window3;
+
+  MockDelegate<HostWindowManager>* delegate =
+      new testing::StrictMock<MockDelegate<HostWindowManager> >();
+
+  HostWindowManager* hwm = new HostWindowManager();
+
+  ASSERT_TRUE(hwm->Initialize(static_cast<HWND>(window), delegate));
+  ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&child_window, delegate, hwm));
+
+  // First, destroy window 1 and subsequently create window 2
+  child_window.DestroyWindow();
+
+  ASSERT_TRUE(child_window2.Create(window, kInitialChildWindowRect) != NULL);
+  ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&child_window2, delegate, hwm));
+
+  // Next, create window 3 just before destroying window 2
+  RECT natural_rect = {10, 15, 40, 45};
+  RECT modified_rect = {15, 20, 35, 40};
+
+  ASSERT_TRUE(child_window3.Create(window, kInitialChildWindowRect) != NULL);
+  ExpectNcCalcSizeSequence(
+      &child_window3, delegate, &natural_rect, &natural_rect);
+  child_window2.DestroyWindow();
+
+  ASSERT_NO_FATAL_FAILURE(DoNcCalcSizeSequence(&child_window3, delegate, hwm));
+
+  EXPECT_CALL(*delegate, Die());
+  window.DestroyWindow();
+}
+
+// Must be declared in same namespace as RECT
+void PrintTo(const RECT& rect, ::std::ostream* os) {
+  *os << "{" << rect.left << ", " << rect.top << ", " << rect.right << ", "
+      << rect.bottom << "}";
+}
+
+namespace {
+
+class MockHost : public InfobarWindow::Host {
+ public:
+  MockHost(InfobarWindow* infobar_window,
+           const RECT& natural_dimensions,
+           HWND hwnd)
+      : infobar_window_(infobar_window),
+        natural_dimensions_(natural_dimensions),
+        hwnd_(hwnd) {
+  }
+
+  void SetNaturalDimensions(const RECT& natural_dimensions) {
+    natural_dimensions_ = natural_dimensions;
+    UpdateLayout();
+  }
+
+  virtual HWND GetContainerWindow() {
+    return hwnd_;
+  }
+
+  virtual void UpdateLayout() {
+    RECT temp(natural_dimensions_);
+    infobar_window_->ReserveSpace(&temp);
+    CheckReservedSpace(&temp);
+  }
+
+  MOCK_METHOD0(Die, void(void));
+
+  // Convenience method for checking the result of InfobarWindow::ReserveSpace
+  MOCK_METHOD1(CheckReservedSpace, void(RECT* rect));
+
+ private:
+  InfobarWindow* infobar_window_;
+  RECT natural_dimensions_;
+  HWND hwnd_;
+};  // class MockHost
+
+class MockInfobarContent : public InfobarContent {
+ public:
+  virtual ~MockInfobarContent() { Die(); }
+
+  MOCK_METHOD1(InstallInFrame,  bool(Frame* frame));
+  MOCK_METHOD1(SetDimensions, void(const RECT& dimensions));
+  MOCK_METHOD2(GetDesiredSize, size_t(size_t width, size_t height));
+  MOCK_METHOD0(Die, void(void));
+};  // class MockInfobarContent
+
+MATCHER_P(
+    RectHeightIsLTEToRectXHeight, rect_x, "height is <= to height of rect x") {
+  return arg.bottom - arg.top <= rect_x->bottom - rect_x->top;
+}
+
+MATCHER_P(
+    RectHeightIsGTEToRectXHeight, rect_x, "height is >= to height of rect x") {
+  return arg.bottom - arg.top >= rect_x->bottom - rect_x->top;
+}
+
+MATCHER_P3(RectIsTopXToYOfRectZ, x, y, rect_z, "is top x to y of rect z" ) {
+  return rect_z->top == arg.top &&
+      rect_z->left == arg.left &&
+      rect_z->right == arg.right &&
+      arg.bottom - arg.top >= x &&
+      arg.bottom - arg.top <= y;
+}
+
+MATCHER_P2(RectAddedToRectXMakesRectY,
+           rect_x,
+           rect_y,
+           "rect added to rect x makes rect y") {
+  if (::IsRectEmpty(rect_x))
+    return ::EqualRect(arg, rect_y);
+
+  if (::IsRectEmpty(arg))
+    return ::EqualRect(rect_x, rect_y);
+
+  // Either they are left and right slices, or top and bottom slices
+  if (!((rect_x->left == rect_y->left && rect_x->right == rect_y->right &&
+         arg->left == rect_y->left && arg->right == rect_y->right) ||
+        (rect_x->top == rect_y->top && rect_x->bottom== rect_y->bottom &&
+         arg->top == rect_y->top && arg->bottom == rect_y->bottom))) {
+    return false;
+  }
+
+  RECT expected_arg;
+
+  if (!::SubtractRect(&expected_arg, rect_y, rect_x))
+    return false;  // Given above checks, the difference should not be empty
+
+  return ::EqualRect(arg, &expected_arg);
+}
+
+MATCHER_P(FrameHwndIs, hwnd, "") {
+  return arg != NULL && arg->GetFrameWindow() == hwnd;
+}
+
+ACTION_P(CheckSetFlag, flag) {
+  ASSERT_FALSE(*flag);
+  *flag = true;
+}
+
+ACTION_P(ResetFlag, flag) {
+  *flag = false;
+}
+
+ACTION_P2(AsynchronousCloseOnFrame, loop, frame) {
+  loop->PostDelayedTask(
+      FROM_HERE,
+      NewRunnableMethod(*frame, &InfobarContent::Frame::CloseInfobar),
+      0);
+}
+
+ACTION_P2(AsynchronousHideOnManager, loop, manager) {
+  loop->PostDelayedTask(
+      FROM_HERE,
+      NewRunnableMethod(manager, &InfobarManager::Hide, TOP_INFOBAR),
+      0);
+}
+
+};  // namespace
+
+// The test ensures that the content is sized at least once in each of the
+// following ranges while fully opening and closing:
+//
+// [0, infobar_height / 2)
+// [infobar_height / 2, infobar_height)
+// [infobar_height, infobar_height]
+// (infobar_height / 2, infobar_height]
+// [0, infobar_height / 2]
+//
+// If the test turns out to be flaky (i.e., because timers are not firing
+// frequently enough to hit all the ranges), increasing the infobar_height
+// should increase the margin (by increasing the time spent in each range).
+TEST(InfobarsInfobarWindowTest, SlidingTest) {
+  int infobar_height = 40;
+
+  chrome_frame_test::TimedMsgLoop message_loop;
+
+  RECT natural_dimensions = {10, 20, 90, 100 + infobar_height};
+
+  // Used to verify that the last RECT given to SetDimensions is the same RECT
+  // reserved by ReserveSpace.
+  RECT current_infobar_dimensions = {0, 0, 0, 0};  // Used to verify that the
+
+  // Used to make sure that each SetDimensions is matched by a return from
+  // ReserveSpace.
+  bool pending_reserve_space = false;
+
+  InfobarWindow infobar_window(TOP_INFOBAR);
+
+  testing::NiceMock<MockTopLevelWindow> window;
+  ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect));
+  HWND hwnd = static_cast<HWND>(window);
+  MockInfobarContent* content = new MockInfobarContent();
+  scoped_ptr<MockHost> host(new MockHost(&infobar_window,
+                                         natural_dimensions,
+                                         hwnd));
+
+  infobar_window.SetHost(host.get());
+
+  // Used to ensure that GetDesiredSize is only called on an installed
+  // InfobarContent.
+  testing::Expectation installed;
+
+  // Will hold the frame given to us in InfobarContent::InstallInFrame.
+  InfobarContent::Frame* frame = NULL;
+
+  // We could get any number of calls to UpdateLayout. Make sure that, each
+  // time, the space reserved by the InfobarWindow equals the space offered to
+  // the InfobarContent.
+  EXPECT_CALL(*host, CheckReservedSpace(RectAddedToRectXMakesRectY(
+      &current_infobar_dimensions, &natural_dimensions)))
+      .Times(testing::AnyNumber())
+      .WillRepeatedly(ResetFlag(&pending_reserve_space));
+
+  testing::MockFunction<void(std::string check_point_name)> check;
+
+  {
+    testing::InSequence s;
+    // During Show(), we get an InstallInFrame
+    installed = EXPECT_CALL(*content, InstallInFrame(FrameHwndIs(hwnd)))
+        .WillOnce(testing::DoAll(testing::SaveArg<0>(&frame),
+                                 testing::Return(true)));
+
+    // Allow a call to SetDimensions before InstallInFrame returns.
+    EXPECT_CALL(*content, SetDimensions(testing::AllOf(
+        RectIsTopXToYOfRectZ(0, infobar_height / 2 - 1, &natural_dimensions),
+        RectHeightIsGTEToRectXHeight(&current_infobar_dimensions))))
+        .Times(testing::AnyNumber()).WillRepeatedly(testing::DoAll(
+            testing::SaveArg<0>(&current_infobar_dimensions),
+            CheckSetFlag(&pending_reserve_space)));
+
+    EXPECT_CALL(check, Call("returned from Show"));
+
+    EXPECT_CALL(*content, SetDimensions(testing::AllOf(
+        RectIsTopXToYOfRectZ(0, infobar_height / 2 - 1, &natural_dimensions),
+        RectHeightIsGTEToRectXHeight(&current_infobar_dimensions))))
+        .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
+            testing::SaveArg<0>(&current_infobar_dimensions),
+            CheckSetFlag(&pending_reserve_space)));
+    EXPECT_CALL(*content, SetDimensions(testing::AllOf(
+        RectIsTopXToYOfRectZ(infobar_height / 2,
+                             infobar_height - 1,
+                             &natural_dimensions),
+        RectHeightIsGTEToRectXHeight(&current_infobar_dimensions))))
+        .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
+            testing::SaveArg<0>(&current_infobar_dimensions),
+            CheckSetFlag(&pending_reserve_space)));
+    EXPECT_CALL(*content, SetDimensions(
+        RectIsTopXToYOfRectZ(infobar_height,
+                             infobar_height,
+                             &natural_dimensions)))
+        .WillOnce(testing::DoAll(
+            testing::SaveArg<0>(&current_infobar_dimensions),
+            CheckSetFlag(&pending_reserve_space),
+            AsynchronousCloseOnFrame(&message_loop, &frame)));
+
+    EXPECT_CALL(*content, SetDimensions(testing::AllOf(
+        RectIsTopXToYOfRectZ(infobar_height / 2 + 1,
+                             infobar_height,
+                             &natural_dimensions),
+        RectHeightIsLTEToRectXHeight(&current_infobar_dimensions))))
+        .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
+            testing::SaveArg<0>(&current_infobar_dimensions),
+            CheckSetFlag(&pending_reserve_space)));
+    EXPECT_CALL(*content, SetDimensions(testing::AllOf(
+        RectIsTopXToYOfRectZ(0, infobar_height / 2, &natural_dimensions),
+        RectHeightIsLTEToRectXHeight(&current_infobar_dimensions))))
+        .Times(testing::AtLeast(1)).WillRepeatedly(testing::DoAll(
+            testing::SaveArg<0>(&current_infobar_dimensions),
+            CheckSetFlag(&pending_reserve_space)));
+
+    EXPECT_CALL(*content, Die()).WillOnce(QUIT_LOOP(message_loop));
+  }
+
+  EXPECT_CALL(*content, GetDesiredSize(80, 0))
+      .Times(testing::AnyNumber()).After(installed)
+      .WillRepeatedly(testing::Return(infobar_height));
+
+  ASSERT_NO_FATAL_FAILURE(infobar_window.Show(content));
+
+  ASSERT_NO_FATAL_FAILURE(check.Call("returned from Show"));
+
+  ASSERT_NO_FATAL_FAILURE(message_loop.RunFor(10));  // seconds
+
+  window.DestroyWindow();
+
+  ASSERT_FALSE(message_loop.WasTimedOut());
+}
+
+TEST(InfobarsInfobarManagerTest, BasicTest) {
+  chrome_frame_test::TimedMsgLoop message_loop;
+
+  int infobar_height = 40;
+  RECT natural_dimensions = {10, 20, 90, 100 + infobar_height};
+
+  testing::NiceMock<MockTopLevelWindow> window;
+  ASSERT_TRUE(window.Create(NULL, kInitialParentWindowRect) != NULL);
+  testing::NiceMock<MockChildWindow> child_window;
+  ASSERT_TRUE(child_window.Create(window, kInitialChildWindowRect) != NULL);
+
+  HWND parent_hwnd = static_cast<HWND>(window);
+  HWND child_hwnd = static_cast<HWND>(child_window);
+
+  MockInfobarContent* content = new MockInfobarContent();
+  InfobarContent::Frame* frame = NULL;
+
+  InfobarManager* manager = InfobarManager::Get(parent_hwnd);
+  ASSERT_FALSE(manager == NULL);
+
+  EXPECT_CALL(*content, GetDesiredSize(80, 0))
+      .Times(testing::AnyNumber())
+      .WillRepeatedly(testing::Return(infobar_height));
+
+  EXPECT_CALL(child_window, OnNcCalcSize(true, testing::_))
+      .Times(testing::AnyNumber()).WillRepeatedly(
+          RespondToNcCalcSize(0, &natural_dimensions));
+
+  EXPECT_CALL(*content, InstallInFrame(FrameHwndIs(parent_hwnd)))
+      .WillOnce(testing::DoAll(testing::SaveArg<0>(&frame),
+                               testing::Return(true)));
+
+  EXPECT_CALL(*content, SetDimensions(testing::Not(
+      RectIsTopXToYOfRectZ(infobar_height,
+                           infobar_height,
+                           &natural_dimensions)))).Times(testing::AnyNumber());
+
+  EXPECT_CALL(*content, SetDimensions(
+      RectIsTopXToYOfRectZ(infobar_height,
+                           infobar_height,
+                           &natural_dimensions)))
+      .Times(testing::AnyNumber())
+      .WillOnce(AsynchronousHideOnManager(&message_loop, manager))
+      .WillRepeatedly(testing::Return());
+
+  EXPECT_CALL(*content, Die()).WillOnce(QUIT_LOOP(message_loop));
+
+  ASSERT_TRUE(manager->Show(content, TOP_INFOBAR));
+
+  message_loop.RunFor(10);  // seconds
+
+  window.DestroyWindow();
+
+  ASSERT_FALSE(message_loop.WasTimedOut());
+}
+
+// TODO(erikwright): Write test for variations on return from default
+// OnNcCalcValidRects