bcarrella
/
cef
mirror of https://bitbucket.org/chromiumembedded/cef
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cef/tests/ceftests/views/panel_unittest.cc

1395 lines
46 KiB
C++
Raw Blame History

// 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)
Reference in New Issue View Git Blame Copy Permalink