path: root/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 "testing/gtest/include/gtest/gtest.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "chrome_frame/infobars/infobar_content.h"
#include "chrome_frame/infobars/internal/displaced_window_manager.h"
#include "chrome_frame/infobars/internal/host_window_manager.h"
#include "chrome_frame/infobars/internal/infobar_window.h"
#include "chrome_frame/infobars/internal/subclassing_window_with_delegate.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)));

  EXPECT_CALL(*mock_window, OnNcCalcSize(true, testing::_))
    .Times(testing::Between(0, 1))
    .WillOnce(RespondToNcCalcSize(0, natural_rect));
  EXPECT_CALL(*delegate,
              AdjustDisplacedWindowDimensions(EqualRect(natural_rect)))
    .Times(testing::Between(0, 1))
    .WillOnce(testing::SetArgumentPointee<0>(*modified_rect));
  EXPECT_CALL(*mock_window, OnMove(CPoint(modified_rect->left,
                                          modified_rect->top)))
    .Times(testing::Between(0, 1));
  EXPECT_CALL(*mock_window,
              OnSize(0, CSize(modified_rect->right - modified_rect->left,
                              modified_rect->bottom - modified_rect->top)))
    .Times(testing::Between(0, 1));

}

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();

  testing::Mock::VerifyAndClearExpectations(mock_window);
  testing::Mock::VerifyAndClearExpectations(delegate);

  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