src/tests/ceftests/views/panel_unittest.cc

// Copyright (c) 2016 The Chromium Embedded Framework 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 "include/views/cef_box_layout.h"
#include "include/views/cef_fill_layout.h"
#include "include/views/cef_layout.h"
#include "include/views/cef_panel.h"
#include "include/views/cef_panel_delegate.h"
#include "include/views/cef_window.h"
#include "tests/ceftests/thread_helper.h"
#include "tests/gtest/include/gtest/gtest.h"

#define PANEL_TEST(name) UI_THREAD_TEST(ViewsPanelTest, name)

namespace {

class EmptyPanelDelegate : public CefPanelDelegate {
 public:
  EmptyPanelDelegate() {}

 private:
  IMPLEMENT_REFCOUNTING(EmptyPanelDelegate);
  DISALLOW_COPY_AND_ASSIGN(EmptyPanelDelegate);
};

void CreatePanel(CefRefPtr<CefPanelDelegate> delegate) {
  CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);
  EXPECT_TRUE(panel.get());

  // Verify the derived View relationship.
  EXPECT_TRUE(panel->AsPanel().get());
  EXPECT_FALSE(panel->AsWindow().get());
  EXPECT_TRUE(panel->IsSame(panel));

  // Verify default View state.
  EXPECT_STREQ("Panel", panel->GetTypeString().ToString().c_str());
  EXPECT_TRUE(panel->IsValid());
  EXPECT_FALSE(panel->IsAttached());
  if (delegate)
    EXPECT_EQ(delegate.get(), panel->GetDelegate().get());
  else
    EXPECT_FALSE(panel->GetDelegate().get());
  EXPECT_EQ(0, panel->GetID());
  EXPECT_FALSE(panel->GetParentView().get());
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBoundsInScreen());
  EXPECT_EQ(CefSize(0, 0), panel->GetPreferredSize());
  EXPECT_EQ(CefSize(0, 0), panel->GetMinimumSize());
  EXPECT_EQ(CefSize(0, 0), panel->GetMaximumSize());
  EXPECT_EQ(CefSize(0, 0), panel->GetMaximumSize());
  EXPECT_EQ(0, panel->GetHeightForWidth(100));
  EXPECT_TRUE(panel->IsVisible());
  EXPECT_FALSE(panel->IsDrawn());
  EXPECT_TRUE(panel->IsEnabled());
  EXPECT_FALSE(panel->IsFocusable());
  EXPECT_FALSE(panel->IsAccessibilityFocusable());
  EXPECT_EQ(CefColorSetARGB(255, 255, 255, 255), panel->GetBackgroundColor());

  // Verify default Panel state.
  EXPECT_TRUE(panel->GetLayout().get());
  EXPECT_EQ(0U, panel->GetChildViewCount());

  // Destroy the Panel.
  panel = nullptr;

  if (delegate) {
    // Verify that nothing is keeping a reference to the delegate.
    EXPECT_TRUE(delegate->HasOneRef());
  }
}

void CreatePanelNoDelegateImpl() {
  CreatePanel(nullptr);
}

void CreatePanelWithDelegateImpl() {
  CreatePanel(new EmptyPanelDelegate);
}

}  // namespace

// Test creation.
PANEL_TEST(CreatePanelNoDelegate)
PANEL_TEST(CreatePanelWithDelegate)

namespace {

class ParentPanelDelegate : public CefPanelDelegate {
 public:
  ParentPanelDelegate() {}

  void OnParentViewChanged(CefRefPtr<CefView> view,
                           bool added,
                           CefRefPtr<CefView> parent) override {
    EXPECT_FALSE(true);  // Not reached.
  }

  void OnChildViewChanged(CefRefPtr<CefView> view,
                          bool added,
                          CefRefPtr<CefView> child) override {
    Changed changed;
    changed.view_ = view;
    changed.added_ = added;
    changed.child_ = child;
    changed_.push_back(changed);
  }

  void Verify(int callback_index,
              CefRefPtr<CefView> view,
              bool added,
              CefRefPtr<CefView> child) {
    EXPECT_LT(callback_index, static_cast<int>(changed_.size()));
    EXPECT_TRUE(view->IsSame(changed_[callback_index].view_))
        << "callback_index " << callback_index;
    EXPECT_EQ(added, changed_[callback_index].added_)
        << "callback_index " << callback_index;
    EXPECT_TRUE(child->IsSame(changed_[callback_index].child_))
        << "callback_index " << callback_index;
  }

  void Reset() { changed_.clear(); }

  bool IsReset() const { return changed_.empty(); }

  struct Changed {
    CefRefPtr<CefView> view_;
    bool added_ = false;
    CefRefPtr<CefView> child_;
  };
  std::vector<Changed> changed_;

 private:
  IMPLEMENT_REFCOUNTING(ParentPanelDelegate);
  DISALLOW_COPY_AND_ASSIGN(ParentPanelDelegate);
};

class ChildPanelDelegate : public CefPanelDelegate {
 public:
  ChildPanelDelegate() {}

  void OnParentViewChanged(CefRefPtr<CefView> view,
                           bool added,
                           CefRefPtr<CefView> parent) override {
    EXPECT_FALSE(on_parent_view_changed_);
    on_parent_view_changed_ = true;
    view_ = view;
    added_ = added;
    parent_ = parent;
  }

  void OnChildViewChanged(CefRefPtr<CefView> view,
                          bool added,
                          CefRefPtr<CefView> child) override {
    EXPECT_FALSE(true);  // Not reached.
  }

  void Verify(CefRefPtr<CefView> view, bool added, CefRefPtr<CefView> parent) {
    EXPECT_TRUE(on_parent_view_changed_);
    EXPECT_TRUE(view->IsSame(view_));
    EXPECT_EQ(added, added_);
    EXPECT_TRUE(parent->IsSame(parent_));
  }

  void Reset() {
    on_parent_view_changed_ = false;
    view_ = nullptr;
    added_ = false;
    parent_ = nullptr;
  }

  bool IsReset() const { return !on_parent_view_changed_; }

  bool on_parent_view_changed_ = false;
  CefRefPtr<CefView> view_;
  bool added_ = false;
  CefRefPtr<CefView> parent_;

 private:
  IMPLEMENT_REFCOUNTING(ChildPanelDelegate);
  DISALLOW_COPY_AND_ASSIGN(ChildPanelDelegate);
};

void ChildVerifyRemovedState(CefRefPtr<ParentPanelDelegate> parent_delegate,
                             CefRefPtr<CefPanel> parent_panel,
                             CefRefPtr<ChildPanelDelegate> child_delegate,
                             CefRefPtr<CefPanel> child_panel) {
  EXPECT_FALSE(parent_panel->IsSame(child_panel));
  EXPECT_FALSE(child_panel->IsSame(parent_panel));
  EXPECT_FALSE(parent_panel->IsAttached());
  EXPECT_FALSE(child_panel->IsAttached());
  EXPECT_FALSE(parent_panel->GetParentView().get());
  EXPECT_FALSE(child_panel->GetParentView().get());
}

void ChildVerifyAddedState(CefRefPtr<ParentPanelDelegate> parent_delegate,
                           CefRefPtr<CefPanel> parent_panel,
                           CefRefPtr<ChildPanelDelegate> child_delegate,
                           CefRefPtr<CefPanel> child_panel,
                           int expected_child_index) {
  EXPECT_FALSE(parent_panel->IsSame(child_panel));
  EXPECT_FALSE(child_panel->IsSame(parent_panel));
  EXPECT_FALSE(parent_panel->IsAttached());
  EXPECT_TRUE(child_panel->IsAttached());
  EXPECT_TRUE(
      child_panel->IsSame(parent_panel->GetChildViewAt(expected_child_index)));
  EXPECT_TRUE(child_panel->GetParentView()->IsSame(parent_panel));
}

void ChildVerifyFinalCallbackState(
    CefRefPtr<ParentPanelDelegate> parent_delegate,
    CefRefPtr<CefPanel> parent_panel,
    CefRefPtr<ChildPanelDelegate> child_delegate,
    CefRefPtr<CefPanel> child_panel,
    int expected_parent_callback_index,
    bool added) {
  parent_delegate->Verify(expected_parent_callback_index, parent_panel, added,
                          child_panel);
  child_delegate->Verify(child_panel, added, parent_panel);
}

void ChildAdd(CefRefPtr<ParentPanelDelegate> parent_delegate,
              CefRefPtr<CefPanel> parent_panel,
              CefRefPtr<ChildPanelDelegate> child_delegate,
              CefRefPtr<CefPanel> child_panel,
              int expected_child_index = 0,
              int expected_parent_callback_index = 0) {
  // Verify initial parent/child state.
  ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate,
                          child_panel);

  // Verify initial child callback state.
  EXPECT_TRUE(child_delegate->IsReset());

  // Add the child view.
  parent_panel->AddChildView(child_panel);

  // Verify final callback state.
  ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate,
                                child_panel, expected_parent_callback_index,
                                true);

  // Reset child callback state.
  child_delegate->Reset();

  // Verify final parent/child state.
  ChildVerifyAddedState(parent_delegate, parent_panel, child_delegate,
                        child_panel, expected_child_index);
}

void ChildAddAt(CefRefPtr<ParentPanelDelegate> parent_delegate,
                CefRefPtr<CefPanel> parent_panel,
                CefRefPtr<ChildPanelDelegate> child_delegate,
                CefRefPtr<CefPanel> child_panel,
                int child_index,
                int expected_parent_callback_index) {
  // Verify initial parent/child state.
  ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate,
                          child_panel);

  // Verify initial child callback state.
  EXPECT_TRUE(child_delegate->IsReset());

  // Add the child view.
  parent_panel->AddChildViewAt(child_panel, child_index);

  // Verify final callback state.
  ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate,
                                child_panel, expected_parent_callback_index,
                                true);

  // Reset child callback state.
  child_delegate->Reset();

  // Verify final parent/child state.
  ChildVerifyAddedState(parent_delegate, parent_panel, child_delegate,
                        child_panel, child_index);
}

void ChildRemove(CefRefPtr<ParentPanelDelegate> parent_delegate,
                 CefRefPtr<CefPanel> parent_panel,
                 CefRefPtr<ChildPanelDelegate> child_delegate,
                 CefRefPtr<CefPanel> child_panel,
                 bool remove_all,
                 int expected_child_index = 0,
                 int expected_parent_callback_index = 0) {
  // Verify initial parent/child state.
  ChildVerifyAddedState(parent_delegate, parent_panel, child_delegate,
                        child_panel, expected_child_index);

  // Verify initial child callback state.
  EXPECT_TRUE(child_delegate->IsReset());

  // Remove the child view.
  if (remove_all)
    parent_panel->RemoveAllChildViews();
  else
    parent_panel->RemoveChildView(child_panel);

  // Verify final callback state.
  ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate,
                                child_panel, expected_parent_callback_index,
                                false);

  // Reset child callback state.
  child_delegate->Reset();

  // Verify final parent/child state.
  ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate,
                          child_panel);
}

void ChildAddRemoveSingleImpl() {
  CefRefPtr<ParentPanelDelegate> parent_delegate = new ParentPanelDelegate();
  CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(parent_delegate);

  CefRefPtr<ChildPanelDelegate> child_delegate = new ChildPanelDelegate();
  CefRefPtr<CefPanel> child_panel = CefPanel::CreatePanel(child_delegate);

  // Add and explicitly remove the child view.
  EXPECT_TRUE(parent_delegate->IsReset());
  ChildAdd(parent_delegate, parent_panel, child_delegate, child_panel);
  parent_delegate->Reset();

  ChildRemove(parent_delegate, parent_panel, child_delegate, child_panel,
              false);
  parent_delegate->Reset();

  // Add and implicitly remove the child view.
  ChildAdd(parent_delegate, parent_panel, child_delegate, child_panel);
  parent_delegate->Reset();

  ChildRemove(parent_delegate, parent_panel, child_delegate, child_panel,
              false);
  parent_delegate->Reset();
}

void ChildAddRemoveMultipleImpl() {
  CefRefPtr<ParentPanelDelegate> parent_delegate = new ParentPanelDelegate();
  CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(parent_delegate);

  CefRefPtr<ChildPanelDelegate> child_delegate1 = new ChildPanelDelegate();
  CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(child_delegate1);

  CefRefPtr<ChildPanelDelegate> child_delegate2 = new ChildPanelDelegate();
  CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(child_delegate2);

  // Add multiple child views.
  EXPECT_TRUE(parent_delegate->IsReset());
  ChildAdd(parent_delegate, parent_panel, child_delegate1, child_panel1, 0, 0);
  EXPECT_TRUE(child_delegate2->IsReset());  // child2 not called.
  ChildAdd(parent_delegate, parent_panel, child_delegate2, child_panel2, 1, 1);
  EXPECT_TRUE(child_delegate1->IsReset());  // child1 not called.
  parent_delegate->Reset();

  EXPECT_EQ(2U, parent_panel->GetChildViewCount());

  // Explicitly remove specific child views.
  ChildRemove(parent_delegate, parent_panel, child_delegate1, child_panel1,
              false, 0, 0);
  EXPECT_TRUE(child_delegate2->IsReset());  // child2 not called.
  ChildRemove(parent_delegate, parent_panel, child_delegate2, child_panel2,
              false, 0, 1);
  EXPECT_TRUE(child_delegate1->IsReset());  // child1 not called.
  parent_delegate->Reset();

  EXPECT_EQ(0U, parent_panel->GetChildViewCount());

  // Add multiple child views.
  ChildAdd(parent_delegate, parent_panel, child_delegate1, child_panel1, 0, 0);
  EXPECT_TRUE(child_delegate2->IsReset());  // child2 not called.
  ChildAdd(parent_delegate, parent_panel, child_delegate2, child_panel2, 1, 1);
  EXPECT_TRUE(child_delegate1->IsReset());  // child1 not called.
  parent_delegate->Reset();

  EXPECT_EQ(2U, parent_panel->GetChildViewCount());

  EXPECT_TRUE(child_delegate1->IsReset());
  EXPECT_TRUE(child_delegate2->IsReset());

  // Implicitly remove all child views.
  parent_panel->RemoveAllChildViews();

  // Verify final callback state.
  ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate1,
                                child_panel1, 0, false);
  ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate2,
                                child_panel2, 1, false);

  EXPECT_EQ(0U, parent_panel->GetChildViewCount());

  // Reset callback state.
  parent_delegate->Reset();
  child_delegate1->Reset();
  child_delegate2->Reset();

  // Verify final parent/child state.
  ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate1,
                          child_panel1);
  ChildVerifyRemovedState(parent_delegate, parent_panel, child_delegate2,
                          child_panel2);
}

void ChildOrderImpl() {
  CefRefPtr<ParentPanelDelegate> parent_delegate = new ParentPanelDelegate();
  CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(parent_delegate);

  CefRefPtr<ChildPanelDelegate> child_delegate1 = new ChildPanelDelegate();
  CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(child_delegate1);

  CefRefPtr<ChildPanelDelegate> child_delegate2 = new ChildPanelDelegate();
  CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(child_delegate2);

  CefRefPtr<ChildPanelDelegate> child_delegate3 = new ChildPanelDelegate();
  CefRefPtr<CefPanel> child_panel3 = CefPanel::CreatePanel(child_delegate3);

  // Add child views at specific indexes.
  ChildAddAt(parent_delegate, parent_panel, child_delegate2, child_panel2, 0,
             0);
  ChildAddAt(parent_delegate, parent_panel, child_delegate3, child_panel3, 0,
             1);
  ChildAddAt(parent_delegate, parent_panel, child_delegate1, child_panel1, 1,
             2);
  parent_delegate->Reset();

  EXPECT_EQ(3U, parent_panel->GetChildViewCount());

  // ChildAddAt() will verify these results but let's check again just to make
  // sure.
  EXPECT_TRUE(child_panel3->IsSame(parent_panel->GetChildViewAt(0)));
  EXPECT_TRUE(child_panel1->IsSame(parent_panel->GetChildViewAt(1)));
  EXPECT_TRUE(child_panel2->IsSame(parent_panel->GetChildViewAt(2)));

  // Move panel2 to the front.
  parent_panel->ReorderChildView(child_panel2, 0);

  EXPECT_TRUE(child_panel2->IsSame(parent_panel->GetChildViewAt(0)));
  EXPECT_TRUE(child_panel3->IsSame(parent_panel->GetChildViewAt(1)));
  EXPECT_TRUE(child_panel1->IsSame(parent_panel->GetChildViewAt(2)));

  // Move panel3 to the end.
  parent_panel->ReorderChildView(child_panel3, -1);

  EXPECT_TRUE(child_panel2->IsSame(parent_panel->GetChildViewAt(0)));
  EXPECT_TRUE(child_panel1->IsSame(parent_panel->GetChildViewAt(1)));
  EXPECT_TRUE(child_panel3->IsSame(parent_panel->GetChildViewAt(2)));
}

void ChildVisibleImpl() {
  CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(nullptr);
  CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(nullptr);
  CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(nullptr);

  // Nothing drawn by default.
  EXPECT_FALSE(parent_panel->IsDrawn());
  EXPECT_FALSE(child_panel1->IsDrawn());
  EXPECT_FALSE(child_panel2->IsDrawn());

  // Everything visible by default.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel2->IsVisible());

  parent_panel->AddChildView(child_panel1);
  parent_panel->AddChildView(child_panel2);

  // Still the same.
  EXPECT_FALSE(parent_panel->IsDrawn());
  EXPECT_FALSE(child_panel1->IsDrawn());
  EXPECT_FALSE(child_panel2->IsDrawn());
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel2->IsVisible());

  child_panel1->SetVisible(false);

  // Child1 not visible.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_FALSE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel2->IsVisible());

  child_panel1->SetVisible(true);

  // Everything visible.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel2->IsVisible());

  parent_panel->SetVisible(false);

  // Children visible.
  EXPECT_FALSE(parent_panel->IsVisible());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel2->IsVisible());

  parent_panel->SetVisible(true);

  // Everything visible.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel2->IsVisible());
}

void ChildDrawnImpl() {
  CefRefPtr<CefPanel> parent_panel = CefPanel::CreatePanel(nullptr);
  CefRefPtr<CefPanel> child_panel1 = CefPanel::CreatePanel(nullptr);
  CefRefPtr<CefPanel> child_panel2 = CefPanel::CreatePanel(nullptr);

  // Nothing drawn by default.
  EXPECT_FALSE(parent_panel->IsDrawn());
  EXPECT_FALSE(child_panel1->IsDrawn());
  EXPECT_FALSE(child_panel2->IsDrawn());

  // Everything visible by default.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel2->IsVisible());

  parent_panel->AddChildView(child_panel1);
  parent_panel->AddChildView(child_panel2);

  // Create and show a Window.
  CefRefPtr<CefWindow> window = CefWindow::CreateTopLevelWindow(nullptr);
  window->AddChildView(parent_panel);
  window->CenterWindow(CefSize(400, 400));
  window->Show();

  // Everything visible and drawn now.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(parent_panel->IsDrawn());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel1->IsDrawn());
  EXPECT_TRUE(child_panel2->IsVisible());
  EXPECT_TRUE(child_panel2->IsDrawn());

  child_panel1->SetVisible(false);

  // Child1 not visible or drawn.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(parent_panel->IsDrawn());
  EXPECT_FALSE(child_panel1->IsVisible());
  EXPECT_FALSE(child_panel1->IsDrawn());
  EXPECT_TRUE(child_panel2->IsVisible());
  EXPECT_TRUE(child_panel2->IsDrawn());

  child_panel1->SetVisible(true);

  // Everything visible and drawn.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(parent_panel->IsDrawn());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel1->IsDrawn());
  EXPECT_TRUE(child_panel2->IsVisible());
  EXPECT_TRUE(child_panel2->IsDrawn());

  parent_panel->SetVisible(false);

  // Children visible, but nothing drawn.
  EXPECT_FALSE(parent_panel->IsVisible());
  EXPECT_FALSE(parent_panel->IsDrawn());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_FALSE(child_panel1->IsDrawn());
  EXPECT_TRUE(child_panel2->IsVisible());
  EXPECT_FALSE(child_panel2->IsDrawn());

  parent_panel->SetVisible(true);

  // Everything visible and drawn.
  EXPECT_TRUE(parent_panel->IsVisible());
  EXPECT_TRUE(parent_panel->IsDrawn());
  EXPECT_TRUE(child_panel1->IsVisible());
  EXPECT_TRUE(child_panel1->IsDrawn());
  EXPECT_TRUE(child_panel2->IsVisible());
  EXPECT_TRUE(child_panel2->IsDrawn());

  // Close the window.
  window->Close();
}

}  // namespace

// Test child behaviors.
PANEL_TEST(ChildAddRemoveSingle)
PANEL_TEST(ChildAddRemoveMultiple)
PANEL_TEST(ChildOrder)
PANEL_TEST(ChildVisible)
PANEL_TEST(ChildDrawn)

namespace {

class SizingPanelDelegate : public CefPanelDelegate {
 public:
  SizingPanelDelegate() {}

  CefSize GetPreferredSize(CefRefPtr<CefView> view) override {
    got_get_preferred_size_ = true;
    view_ = view;
    return preferred_size_;
  }

  CefSize GetMinimumSize(CefRefPtr<CefView> view) override {
    got_get_minimum_size_ = true;
    view_ = view;
    return minimum_size_;
  }

  CefSize GetMaximumSize(CefRefPtr<CefView> view) override {
    got_get_maximum_size_ = true;
    view_ = view;
    return maximum_size_;
  }

  int GetHeightForWidth(CefRefPtr<CefView> view, int width) override {
    got_get_height_for_width_ = true;
    view_ = view;
    width_ = width;
    return height_for_width_;
  }

  void Reset() {
    preferred_size_ = CefSize(0, 0);
    minimum_size_ = CefSize(0, 0);
    maximum_size_ = CefSize(0, 0);
    height_for_width_ = 0;
    got_get_preferred_size_ = false;
    got_get_minimum_size_ = false;
    got_get_maximum_size_ = false;
    got_get_height_for_width_ = false;
    view_ = nullptr;
    width_ = 0;
  }

  bool IsReset() const {
    return !got_get_preferred_size_ && !got_get_minimum_size_ &&
           !got_get_maximum_size_ && !got_get_height_for_width_;
  }

  CefSize preferred_size_;
  CefSize minimum_size_;
  CefSize maximum_size_;
  int height_for_width_ = 0;

  bool got_get_preferred_size_ = false;
  bool got_get_minimum_size_ = false;
  bool got_get_maximum_size_ = false;
  bool got_get_height_for_width_ = false;

  CefRefPtr<CefView> view_;
  int width_ = 0;

 private:
  IMPLEMENT_REFCOUNTING(SizingPanelDelegate);
  DISALLOW_COPY_AND_ASSIGN(SizingPanelDelegate);
};

void SizeNoDelegateImpl() {
  CefRefPtr<SizingPanelDelegate> delegate = new SizingPanelDelegate();
  CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);

  // Default bounds are empty.
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());

  // Set and get the bounds.
  panel->SetBounds(CefRect(100, 100, 200, 200));
  EXPECT_EQ(CefRect(100, 100, 200, 200), panel->GetBounds());
  EXPECT_EQ(CefSize(200, 200), panel->GetSize());
  EXPECT_EQ(CefPoint(100, 100), panel->GetPosition());

  // GetBoundsInScreen() drops the position because there is no Window.
  EXPECT_EQ(CefRect(0, 0, 200, 200), panel->GetBoundsInScreen());

  // Adjust the position but keep the size the same.
  panel->SetPosition(CefPoint(50, 50));
  EXPECT_EQ(CefRect(50, 50, 200, 200), panel->GetBounds());
  EXPECT_EQ(CefSize(200, 200), panel->GetSize());
  EXPECT_EQ(CefPoint(50, 50), panel->GetPosition());

  // Adjust the size but keep the position the same.
  panel->SetSize(CefSize(400, 400));
  EXPECT_EQ(CefRect(50, 50, 400, 400), panel->GetBounds());
  EXPECT_EQ(CefSize(400, 400), panel->GetSize());
  EXPECT_EQ(CefPoint(50, 50), panel->GetPosition());

  // No delegate methods were called during this test.
  EXPECT_TRUE(delegate->IsReset());
}

void SizeWithDelegateImpl() {
  CefRefPtr<SizingPanelDelegate> delegate = new SizingPanelDelegate();
  CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);

  // Default bounds are empty.
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());

  CefSize expected_size(100, 100);

  // Test GetPreferredSize().
  delegate->preferred_size_ = expected_size;
  EXPECT_EQ(expected_size, panel->GetPreferredSize());
  EXPECT_TRUE(delegate->got_get_preferred_size_);
  EXPECT_FALSE(delegate->got_get_minimum_size_);
  EXPECT_FALSE(delegate->got_get_maximum_size_);
  EXPECT_FALSE(delegate->got_get_height_for_width_);
  EXPECT_TRUE(panel->IsSame(delegate->view_));
  delegate->Reset();

  // Test GetMinimumSize().
  delegate->minimum_size_ = expected_size;
  EXPECT_EQ(expected_size, panel->GetMinimumSize());
  EXPECT_FALSE(delegate->got_get_preferred_size_);
  EXPECT_TRUE(delegate->got_get_minimum_size_);
  EXPECT_FALSE(delegate->got_get_maximum_size_);
  EXPECT_FALSE(delegate->got_get_height_for_width_);
  EXPECT_TRUE(panel->IsSame(delegate->view_));
  delegate->Reset();

  // Test GetMaximumSize().
  delegate->maximum_size_ = expected_size;
  EXPECT_EQ(expected_size, panel->GetMaximumSize());
  EXPECT_FALSE(delegate->got_get_preferred_size_);
  EXPECT_FALSE(delegate->got_get_minimum_size_);
  EXPECT_TRUE(delegate->got_get_maximum_size_);
  EXPECT_FALSE(delegate->got_get_height_for_width_);
  EXPECT_TRUE(panel->IsSame(delegate->view_));
  delegate->Reset();

  int expected_width = 200;
  int expected_height = 100;

  // Test GetHeightForWidth().
  delegate->height_for_width_ = expected_height;
  EXPECT_EQ(expected_height, panel->GetHeightForWidth(expected_width));
  EXPECT_FALSE(delegate->got_get_preferred_size_);
  EXPECT_FALSE(delegate->got_get_minimum_size_);
  EXPECT_FALSE(delegate->got_get_maximum_size_);
  EXPECT_TRUE(delegate->got_get_height_for_width_);
  EXPECT_EQ(expected_width, delegate->width_);
  EXPECT_TRUE(panel->IsSame(delegate->view_));
  delegate->Reset();
}

}  // namespace

// Test sizing.
PANEL_TEST(SizeNoDelegate)
PANEL_TEST(SizeWithDelegate)

namespace {

void FillLayoutCreateImpl() {
  CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(nullptr);

  // Explicitly set to FillLayout.
  panel->SetToFillLayout();

  CefRefPtr<CefLayout> layout = panel->GetLayout();
  EXPECT_TRUE(layout.get());
  EXPECT_TRUE(layout->AsFillLayout().get());
}

void FillLayoutSizeToPreferredSizeImpl() {
  CefRefPtr<SizingPanelDelegate> delegate = new SizingPanelDelegate();
  CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(delegate);

  // Default Layout is FillLayout.
  CefRefPtr<CefLayout> layout = panel->GetLayout();
  EXPECT_TRUE(layout.get());
  EXPECT_TRUE(layout->AsFillLayout().get());

  // Default bounds are empty.
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());

  CefSize expected_size(100, 100);

  delegate->preferred_size_ = expected_size;

  // Trigger use of the preferred size.
  panel->Layout();

  EXPECT_TRUE(delegate->got_get_preferred_size_);
  EXPECT_FALSE(delegate->got_get_minimum_size_);
  EXPECT_FALSE(delegate->got_get_maximum_size_);
  EXPECT_FALSE(delegate->got_get_height_for_width_);
  EXPECT_TRUE(panel->IsSame(delegate->view_));
  delegate->Reset();

  // Size is now the preferred size.
  EXPECT_EQ(expected_size, panel->GetSize());

  // No additional delegate methods were called.
  EXPECT_TRUE(delegate->IsReset());
}

void FillLayoutSizeHierarchyImpl() {
  CefRefPtr<CefPanel> panel_parent = CefPanel::CreatePanel(nullptr);
  CefRefPtr<CefPanel> panel_child = CefPanel::CreatePanel(nullptr);

  CefSize expected_size(100, 100);

  // Default Layout is FillLayout.
  CefRefPtr<CefLayout> layout1 = panel_parent->GetLayout();
  EXPECT_TRUE(layout1.get());
  EXPECT_TRUE(layout1->AsFillLayout().get());

  // Default bounds are empty.
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel_parent->GetBounds());
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child->GetBounds());

  // Without delegates the size must be set on the parent.
  panel_parent->SetSize(expected_size);

  // FillLayout is the default Layout. Both panels should end up with the same
  // size.
  panel_parent->AddChildView(panel_child);

  // Force layout.
  panel_parent->Layout();

  // Panels are now the same size.
  EXPECT_EQ(expected_size, panel_parent->GetSize());
  EXPECT_EQ(expected_size, panel_child->GetSize());

  // Resize the parent panel to a larger size.
  CefSize expected_size2(200, 200);
  panel_parent->SetSize(expected_size2);

  // Force layout.
  panel_parent->Layout();

  // Panels are now the larger size.
  EXPECT_EQ(expected_size2, panel_parent->GetSize());
  EXPECT_EQ(expected_size2, panel_child->GetSize());
}

void FillLayoutSizeHierarchyWithDelegate(bool size_from_parent) {
  CefRefPtr<SizingPanelDelegate> delegate_parent = new SizingPanelDelegate();
  CefRefPtr<CefPanel> panel_parent = CefPanel::CreatePanel(delegate_parent);
  CefRefPtr<SizingPanelDelegate> delegate_child = new SizingPanelDelegate();
  CefRefPtr<CefPanel> panel_child = CefPanel::CreatePanel(delegate_child);

  CefSize expected_size(100, 100);

  // The default layout is FillLayout, but explicitly set it anyways just for
  // some testing variety.
  panel_parent->SetToFillLayout();
  panel_child->SetToFillLayout();

  // Default bounds are empty.
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel_parent->GetBounds());
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child->GetBounds());

  // With delegates the size can come from either the parent or child.
  if (size_from_parent)
    delegate_parent->preferred_size_ = expected_size;
  else
    delegate_child->preferred_size_ = expected_size;

  // FillLayout is the default Layout. Both panels should end up with the same
  // size.
  panel_parent->AddChildView(panel_child);

  // No delegate methods were called yet.
  EXPECT_TRUE(delegate_parent->IsReset());
  EXPECT_TRUE(delegate_child->IsReset());

  // Force layout.
  panel_parent->Layout();

  // delegate_parent will be called to get the preferred size for panel_parent.
  EXPECT_TRUE(delegate_parent->got_get_preferred_size_);
  EXPECT_FALSE(delegate_parent->got_get_minimum_size_);
  EXPECT_FALSE(delegate_parent->got_get_maximum_size_);
  EXPECT_FALSE(delegate_parent->got_get_height_for_width_);
  EXPECT_TRUE(panel_parent->IsSame(delegate_parent->view_));
  delegate_parent->Reset();

  // delegate_child will be called to get the preferred size for panel_child.
  EXPECT_TRUE(delegate_child->got_get_preferred_size_);
  EXPECT_FALSE(delegate_child->got_get_minimum_size_);
  EXPECT_FALSE(delegate_child->got_get_maximum_size_);
  EXPECT_FALSE(delegate_child->got_get_height_for_width_);
  EXPECT_TRUE(panel_child->IsSame(delegate_child->view_));
  delegate_child->Reset();

  // Panels are now the same size.
  EXPECT_EQ(expected_size, panel_parent->GetSize());
  EXPECT_EQ(expected_size, panel_child->GetSize());

  // Resize the parent panel to a larger size.
  CefSize expected_size2(200, 200);
  panel_parent->SetSize(expected_size2);

  // Force layout.
  panel_parent->Layout();

  // Panels are now the larger size.
  EXPECT_EQ(expected_size2, panel_parent->GetSize());
  EXPECT_EQ(expected_size2, panel_child->GetSize());

  // No additional delegate methods were called.
  EXPECT_TRUE(delegate_parent->IsReset());
  EXPECT_TRUE(delegate_child->IsReset());
}

void FillLayoutSizeHierarchyFromParentWithDelegateImpl() {
  FillLayoutSizeHierarchyWithDelegate(true);
}

void FillLayoutSizeHierarchyFromChildWithDelegateImpl() {
  FillLayoutSizeHierarchyWithDelegate(false);
}

}  // namespace

// Test FillLayout.
PANEL_TEST(FillLayoutCreate)
PANEL_TEST(FillLayoutSizeToPreferredSize)
PANEL_TEST(FillLayoutSizeHierarchy)
PANEL_TEST(FillLayoutSizeHierarchyFromParentWithDelegate)
PANEL_TEST(FillLayoutSizeHierarchyFromChildWithDelegate)

namespace {

void BoxLayoutCreateImpl() {
  CefRefPtr<CefPanel> panel = CefPanel::CreatePanel(nullptr);

  CefBoxLayoutSettings settings;

  // Explicitly set to BoxLayout.
  panel->SetToBoxLayout(settings);

  CefRefPtr<CefLayout> layout = panel->GetLayout();
  EXPECT_TRUE(layout.get());
  EXPECT_TRUE(layout->AsBoxLayout().get());
}

const int kBLParentSize = 100;
const int kBLChildSize = 10;

void BoxLayoutSizeHierarchy(bool with_delegate,
                            const CefBoxLayoutSettings& settings,
                            const CefRect& expected_child1_bounds,
                            const CefRect& expected_child2_bounds,
                            int child1_flex = 0,
                            int child2_flex = 0) {
  CefRefPtr<SizingPanelDelegate> delegate_parent;
  if (with_delegate)
    delegate_parent = new SizingPanelDelegate();
  CefRefPtr<CefPanel> panel_parent = CefPanel::CreatePanel(delegate_parent);

  CefRefPtr<SizingPanelDelegate> delegate_child1, delegate_child2;
  if (with_delegate) {
    delegate_child1 = new SizingPanelDelegate();
    delegate_child2 = new SizingPanelDelegate();
  }
  CefRefPtr<CefPanel> panel_child1 = CefPanel::CreatePanel(delegate_child1);
  CefRefPtr<CefPanel> panel_child2 = CefPanel::CreatePanel(delegate_child2);

  // Default bounds are empty.
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel_parent->GetBounds());
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child1->GetBounds());
  EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child2->GetBounds());

  // Give the parent a size.
  CefSize initial_parent_size(kBLParentSize, kBLParentSize);
  if (with_delegate)
    delegate_parent->preferred_size_ = initial_parent_size;
  else
    panel_parent->SetSize(initial_parent_size);

  // Give the children a size smaller than the parent.
  CefSize initial_child_size(kBLChildSize, kBLChildSize);
  if (with_delegate) {
    delegate_child1->preferred_size_ = initial_child_size;
    delegate_child2->preferred_size_ = initial_child_size;
  } else {
    panel_child1->SetSize(initial_child_size);
    panel_child2->SetSize(initial_child_size);
  }

  // Set to BoxLayout with |settings|.
  panel_parent->SetToBoxLayout(settings);

  panel_parent->AddChildView(panel_child1);
  panel_parent->AddChildView(panel_child2);

  if (child1_flex > 0 || child2_flex > 0) {
    // Flex will apply relative stretch in the main axis direction.
    CefRefPtr<CefBoxLayout> layout = panel_parent->GetLayout()->AsBoxLayout();
    if (child1_flex > 0)
      layout->SetFlexForView(panel_child1, child1_flex);
    if (child2_flex > 0)
      layout->SetFlexForView(panel_child2, child2_flex);
  }

  if (with_delegate) {
    // No delegate methods were called yet.
    EXPECT_TRUE(delegate_parent->IsReset());
    EXPECT_TRUE(delegate_child1->IsReset());
    EXPECT_TRUE(delegate_child2->IsReset());
  }

  // Force layout.
  panel_parent->Layout();

  if (with_delegate) {
    // delegate_parent will be called to get the preferred size for
    // panel_parent.
    EXPECT_TRUE(delegate_parent->got_get_preferred_size_);
    EXPECT_FALSE(delegate_parent->got_get_minimum_size_);
    EXPECT_FALSE(delegate_parent->got_get_maximum_size_);
    EXPECT_FALSE(delegate_parent->got_get_height_for_width_);
    EXPECT_TRUE(panel_parent->IsSame(delegate_parent->view_));
    delegate_parent->Reset();

    // delegate_child1 will be called to get the preferred size for
    // panel_child1.
    // GetHeightForWidth may also be called depending on the settings.
    EXPECT_TRUE(delegate_child1->got_get_preferred_size_);
    EXPECT_FALSE(delegate_child1->got_get_minimum_size_);
    EXPECT_FALSE(delegate_child1->got_get_maximum_size_);
    EXPECT_TRUE(panel_child1->IsSame(delegate_child1->view_));
    delegate_child1->Reset();

    // delegate_child2 will be called to get the preferred size for
    // panel_child2.
    // GetHeightForWidth may also be called depending on the settings.
    EXPECT_TRUE(delegate_child2->got_get_preferred_size_);
    EXPECT_FALSE(delegate_child2->got_get_minimum_size_);
    EXPECT_FALSE(delegate_child2->got_get_maximum_size_);
    EXPECT_TRUE(panel_child2->IsSame(delegate_child2->view_));
    delegate_child2->Reset();
  }

  // The parent should be the same size.
  EXPECT_EQ(initial_parent_size, panel_parent->GetSize());

  // Children should have the expected bounds.
  EXPECT_EQ(expected_child1_bounds, panel_child1->GetBounds());
  EXPECT_EQ(expected_child2_bounds, panel_child2->GetBounds());

  if (with_delegate) {
    // No additional delegate methods were called.
    EXPECT_TRUE(delegate_parent->IsReset());
    EXPECT_TRUE(delegate_child1->IsReset());
    EXPECT_TRUE(delegate_child2->IsReset());
  }
}

void BoxLayoutSizeHierarchyVerticalStretch(bool with_delegate) {
  // Vertical layout with children stretched along the horizontal axis.
  //
  // -----------
  // |111111111|
  // |222222222|
  // |         |
  // |         |
  // |         |
  // -----------
  //
  CefBoxLayoutSettings settings;

  CefRect expected_child1_bounds(0, 0, kBLParentSize, kBLChildSize);
  CefRect expected_child2_bounds(0, kBLChildSize, kBLParentSize, kBLChildSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds);
}

void BoxLayoutSizeHierarchyVerticalStretchImpl() {
  BoxLayoutSizeHierarchyVerticalStretch(false);
}

void BoxLayoutSizeHierarchyVerticalStretchWithDelegateImpl() {
  BoxLayoutSizeHierarchyVerticalStretch(true);
}

void BoxLayoutSizeHierarchyHorizontalStretch(bool with_delegate) {
  // Horizontal layout with children stretched along the vertical axis.
  //
  // -----------
  // |12       |
  // |12       |
  // |12       |
  // |12       |
  // |12       |
  // -----------
  //
  CefBoxLayoutSettings settings;
  settings.horizontal = true;

  CefRect expected_child1_bounds(0, 0, kBLChildSize, kBLParentSize);
  CefRect expected_child2_bounds(kBLChildSize, 0, kBLChildSize, kBLParentSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds);
}

void BoxLayoutSizeHierarchyHorizontalStretchImpl() {
  BoxLayoutSizeHierarchyHorizontalStretch(false);
}

void BoxLayoutSizeHierarchyHorizontalStretchWithDelegateImpl() {
  BoxLayoutSizeHierarchyHorizontalStretch(true);
}

void BoxLayoutSizeHierarchyVerticalCenter(bool with_delegate) {
  // Vertical layout with children centered along the horizontal axis.
  //
  // -----------
  // |    1    |
  // |    2    |
  // |         |
  // |         |
  // |         |
  // -----------
  //
  CefBoxLayoutSettings settings;
  settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;

  int xoffset = (kBLParentSize - kBLChildSize) / 2;
  CefRect expected_child1_bounds(xoffset, 0, kBLChildSize, kBLChildSize);
  CefRect expected_child2_bounds(xoffset, kBLChildSize, kBLChildSize,
                                 kBLChildSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds);
}

void BoxLayoutSizeHierarchyVerticalCenterImpl() {
  BoxLayoutSizeHierarchyVerticalCenter(false);
}

void BoxLayoutSizeHierarchyVerticalCenterWithDelegateImpl() {
  BoxLayoutSizeHierarchyVerticalCenter(true);
}

void BoxLayoutSizeHierarchyHorizontalCenter(bool with_delegate) {
  // Horizontal layout with children centered along the vertical axis.
  //
  // -----------
  // |         |
  // |         |
  // |12       |
  // |         |
  // |         |
  // -----------
  //
  CefBoxLayoutSettings settings;
  settings.horizontal = true;
  settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;

  int yoffset = (kBLParentSize - kBLChildSize) / 2;
  CefRect expected_child1_bounds(0, yoffset, kBLChildSize, kBLChildSize);
  CefRect expected_child2_bounds(kBLChildSize, yoffset, kBLChildSize,
                                 kBLChildSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds);
}

void BoxLayoutSizeHierarchyHorizontalCenterImpl() {
  BoxLayoutSizeHierarchyHorizontalCenter(false);
}

void BoxLayoutSizeHierarchyHorizontalCenterWithDelegateImpl() {
  BoxLayoutSizeHierarchyHorizontalCenter(true);
}

void BoxLayoutSizeHierarchyVerticalCenterCenter(bool with_delegate) {
  // Vertical layout with children centered along the horizontal and vertical
  // axis.
  //
  // -----------
  // |         |
  // |    1    |
  // |    2    |
  // |         |
  // -----------
  //
  CefBoxLayoutSettings settings;
  settings.main_axis_alignment = CEF_MAIN_AXIS_ALIGNMENT_CENTER;
  settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;

  int xoffset = (kBLParentSize - kBLChildSize) / 2;
  int yoffset = (kBLParentSize - (kBLChildSize * 2)) / 2;
  CefRect expected_child1_bounds(xoffset, yoffset, kBLChildSize, kBLChildSize);
  CefRect expected_child2_bounds(xoffset, yoffset + kBLChildSize, kBLChildSize,
                                 kBLChildSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds);
}

void BoxLayoutSizeHierarchyVerticalCenterCenterImpl() {
  BoxLayoutSizeHierarchyVerticalCenterCenter(false);
}

void BoxLayoutSizeHierarchyVerticalCenterCenterWithDelegateImpl() {
  BoxLayoutSizeHierarchyVerticalCenterCenter(true);
}

void BoxLayoutSizeHierarchyHorizontalCenterCenter(bool with_delegate) {
  // Horizontal layout with children centered along the vertical and horizontal
  // axis.
  //
  // -----------
  // |         |
  // |         |
  // |   12    |
  // |         |
  // |         |
  // -----------
  //
  CefBoxLayoutSettings settings;
  settings.horizontal = true;
  settings.main_axis_alignment = CEF_MAIN_AXIS_ALIGNMENT_CENTER;
  settings.cross_axis_alignment = CEF_CROSS_AXIS_ALIGNMENT_CENTER;

  int xoffset = (kBLParentSize - (kBLChildSize * 2)) / 2;
  int yoffset = (kBLParentSize - kBLChildSize) / 2;
  CefRect expected_child1_bounds(xoffset, yoffset, kBLChildSize, kBLChildSize);
  CefRect expected_child2_bounds(xoffset + kBLChildSize, yoffset, kBLChildSize,
                                 kBLChildSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds);
}

void BoxLayoutSizeHierarchyHorizontalCenterCenterImpl() {
  BoxLayoutSizeHierarchyHorizontalCenterCenter(false);
}

void BoxLayoutSizeHierarchyHorizontalCenterCenterWithDelegateImpl() {
  BoxLayoutSizeHierarchyHorizontalCenterCenter(true);
}

void BoxLayoutSizeHierarchyVerticalStretchFlexOne(bool with_delegate) {
  // Vertical layout with child1 stretched along the horizontal and vertical
  // axis and child2 stretched along the horizontal axis only (unequal flex).
  //
  // -----------
  // |111111111|
  // |111111111|
  // |111111111|
  // |111111111|
  // |222222222|
  // -----------
  //
  CefBoxLayoutSettings settings;

  CefRect expected_child1_bounds(0, 0, kBLParentSize,
                                 kBLParentSize - kBLChildSize);
  CefRect expected_child2_bounds(0, kBLParentSize - kBLChildSize, kBLParentSize,
                                 kBLChildSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds, 1, 0);
}

void BoxLayoutSizeHierarchyVerticalStretchFlexOneImpl() {
  BoxLayoutSizeHierarchyVerticalStretchFlexOne(false);
}

void BoxLayoutSizeHierarchyVerticalStretchFlexOneWithDelegateImpl() {
  BoxLayoutSizeHierarchyVerticalStretchFlexOne(true);
}

void BoxLayoutSizeHierarchyHorizontalStretchFlexOne(bool with_delegate) {
  // Horizontal layout with child1 stretched along the vertical and horizontal
  // axis and child2 stretched along the vertical axis only (unequal flex).
  //
  // -----------
  // |111111112|
  // |111111112|
  // |111111112|
  // |111111112|
  // |111111112|
  // -----------
  //
  CefBoxLayoutSettings settings;
  settings.horizontal = true;

  CefRect expected_child1_bounds(0, 0, kBLParentSize - kBLChildSize,
                                 kBLParentSize);
  CefRect expected_child2_bounds(kBLParentSize - kBLChildSize, 0, kBLChildSize,
                                 kBLParentSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds, 1, 0);
}

void BoxLayoutSizeHierarchyHorizontalStretchFlexOneImpl() {
  BoxLayoutSizeHierarchyHorizontalStretchFlexOne(false);
}

void BoxLayoutSizeHierarchyHorizontalStretchFlexOneWithDelegateImpl() {
  BoxLayoutSizeHierarchyHorizontalStretchFlexOne(true);
}

void BoxLayoutSizeHierarchyVerticalStretchFlexBoth(bool with_delegate) {
  // Vertical layout with children stretched along the horizontal and vertical
  // axis (equal flex).
  //
  // -----------
  // |111111111|
  // |111111111|
  // |111111111|
  // |222222222|
  // |222222222|
  // |222222222|
  // -----------
  //
  CefBoxLayoutSettings settings;

  CefRect expected_child1_bounds(0, 0, kBLParentSize, kBLParentSize / 2);
  CefRect expected_child2_bounds(0, kBLParentSize / 2, kBLParentSize,
                                 kBLParentSize / 2);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds, 1, 1);
}

void BoxLayoutSizeHierarchyVerticalStretchFlexBothImpl() {
  BoxLayoutSizeHierarchyVerticalStretchFlexBoth(false);
}

void BoxLayoutSizeHierarchyVerticalStretchFlexBothWithDelegateImpl() {
  BoxLayoutSizeHierarchyVerticalStretchFlexBoth(true);
}

void BoxLayoutSizeHierarchyHorizontalStretchFlexBoth(bool with_delegate) {
  // Horizontal layout with children stretched along the vertical and horizontal
  // axis (equal flex).
  //
  // -----------
  // |111122222|
  // |111122222|
  // |111122222|
  // |111122222|
  // |111122222|
  // -----------
  //
  CefBoxLayoutSettings settings;
  settings.horizontal = true;

  CefRect expected_child1_bounds(0, 0, kBLParentSize / 2, kBLParentSize);
  CefRect expected_child2_bounds(kBLParentSize / 2, 0, kBLParentSize / 2,
                                 kBLParentSize);

  BoxLayoutSizeHierarchy(with_delegate, settings, expected_child1_bounds,
                         expected_child2_bounds, 1, 1);
}

void BoxLayoutSizeHierarchyHorizontalStretchFlexBothImpl() {
  BoxLayoutSizeHierarchyHorizontalStretchFlexBoth(false);
}

void BoxLayoutSizeHierarchyHorizontalStretchFlexBothWithDelegateImpl() {
  BoxLayoutSizeHierarchyHorizontalStretchFlexBoth(true);
}

}  // namespace

// Test BoxLayout. The BoxLayoutSizeHierarchy* tests are representative but not
// comprehensive (e.g. not all possible configurations are tested).
PANEL_TEST(BoxLayoutCreate)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretch)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretch)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenter)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenterWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenter)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenterWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenterCenter)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalCenterCenterWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenterCenter)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalCenterCenterWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexOne)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexOneWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexOne)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexOneWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexBoth)
PANEL_TEST(BoxLayoutSizeHierarchyVerticalStretchFlexBothWithDelegate)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexBoth)
PANEL_TEST(BoxLayoutSizeHierarchyHorizontalStretchFlexBothWithDelegate)