FlowThreadController.cpp [plain text]
#include "config.h"
#include "FlowThreadController.h"
#include "NamedFlowCollection.h"
#include "RenderFlowThread.h"
#include "RenderLayer.h"
#include "RenderNamedFlowThread.h"
#include "StyleInheritedData.h"
#include "WebKitNamedFlow.h"
#include <wtf/text/AtomicString.h>
namespace WebCore {
FlowThreadController::FlowThreadController(RenderView* view)
: m_view(view)
, m_isRenderNamedFlowThreadOrderDirty(false)
, m_flowThreadsWithAutoLogicalHeightRegions(0)
{
}
FlowThreadController::~FlowThreadController()
{
}
RenderNamedFlowThread& FlowThreadController::ensureRenderFlowThreadWithName(const AtomicString& name)
{
if (!m_renderNamedFlowThreadList)
m_renderNamedFlowThreadList = std::make_unique<RenderNamedFlowThreadList>();
else {
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
if (flowRenderer->flowThreadName() == name)
return *flowRenderer;
}
}
NamedFlowCollection& namedFlows = m_view->document().namedFlows();
ASSERT(!namedFlows.flowByName(name));
auto flowRenderer = new RenderNamedFlowThread(m_view->document(), RenderFlowThread::createFlowThreadStyle(&m_view->style()), namedFlows.ensureFlowWithName(name));
flowRenderer->initializeStyle();
m_renderNamedFlowThreadList->add(flowRenderer);
m_view->addChild(flowRenderer);
setIsRenderNamedFlowThreadOrderDirty(true);
return *flowRenderer;
}
void FlowThreadController::styleDidChange()
{
auto& viewStyle = m_view->style();
for (auto& flowRenderer : *m_renderNamedFlowThreadList)
flowRenderer->setStyle(RenderFlowThread::createFlowThreadStyle(&viewStyle));
}
void FlowThreadController::layoutRenderNamedFlowThreads()
{
updateFlowThreadsChainIfNecessary();
for (auto& flowRenderer : *m_renderNamedFlowThreadList)
flowRenderer->layoutIfNeeded();
}
void FlowThreadController::registerNamedFlowContentElement(Element& contentElement, RenderNamedFlowThread& namedFlow)
{
ASSERT(!m_mapNamedFlowContentElement.contains(&contentElement));
ASSERT(!namedFlow.hasContentElement(contentElement));
m_mapNamedFlowContentElement.add(&contentElement, &namedFlow);
namedFlow.registerNamedFlowContentElement(contentElement);
}
void FlowThreadController::unregisterNamedFlowContentElement(Element& contentElement)
{
auto it = m_mapNamedFlowContentElement.find(&contentElement);
ASSERT(it != m_mapNamedFlowContentElement.end());
ASSERT(it->value);
ASSERT(it->value->hasContentElement(contentElement));
it->value->unregisterNamedFlowContentElement(contentElement);
m_mapNamedFlowContentElement.remove(&contentElement);
}
void FlowThreadController::updateFlowThreadsChainIfNecessary()
{
ASSERT(m_renderNamedFlowThreadList);
ASSERT(isAutoLogicalHeightRegionsCountConsistent());
RenderNamedFlowThreadList toRemoveList;
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
if (flowRenderer->isMarkedForDestruction())
toRemoveList.add(flowRenderer);
}
if (toRemoveList.size() > 0)
setIsRenderNamedFlowThreadOrderDirty(true);
for (auto& flowRenderer : toRemoveList) {
m_renderNamedFlowThreadList->remove(flowRenderer);
flowRenderer->destroy();
}
if (isRenderNamedFlowThreadOrderDirty()) {
RenderNamedFlowThreadList sortedList;
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
if (sortedList.contains(flowRenderer))
continue;
flowRenderer->pushDependencies(sortedList);
sortedList.add(flowRenderer);
}
m_renderNamedFlowThreadList->swap(sortedList);
setIsRenderNamedFlowThreadOrderDirty(false);
}
}
bool FlowThreadController::updateFlowThreadsNeedingLayout()
{
bool needsTwoPassLayout = false;
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
ASSERT(!flowRenderer->needsTwoPhasesLayout());
ASSERT(flowRenderer->inMeasureContentLayoutPhase());
if (flowRenderer->needsLayout() && flowRenderer->hasAutoLogicalHeightRegions())
needsTwoPassLayout = true;
}
if (needsTwoPassLayout)
resetFlowThreadsWithAutoHeightRegions();
return needsTwoPassLayout;
}
bool FlowThreadController::updateFlowThreadsNeedingTwoStepLayout()
{
bool needsTwoPassLayout = false;
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
if (flowRenderer->needsTwoPhasesLayout()) {
needsTwoPassLayout = true;
break;
}
}
if (needsTwoPassLayout)
resetFlowThreadsWithAutoHeightRegions();
return needsTwoPassLayout;
}
void FlowThreadController::resetFlowThreadsWithAutoHeightRegions()
{
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
if (flowRenderer->hasAutoLogicalHeightRegions()) {
flowRenderer->markAutoLogicalHeightRegionsForLayout();
flowRenderer->invalidateRegions();
}
}
}
void FlowThreadController::updateFlowThreadsIntoConstrainedPhase()
{
for (auto iter = m_renderNamedFlowThreadList->rbegin(), end = m_renderNamedFlowThreadList->rend(); iter != end; ++iter) {
RenderNamedFlowThread* flowRenderer = *iter;
ASSERT(!flowRenderer->hasRegions() || flowRenderer->hasValidRegionInfo());
flowRenderer->layoutIfNeeded();
if (flowRenderer->hasAutoLogicalHeightRegions()) {
ASSERT(flowRenderer->needsTwoPhasesLayout());
flowRenderer->markAutoLogicalHeightRegionsForLayout();
}
flowRenderer->setLayoutPhase(RenderFlowThread::LayoutPhaseConstrained);
flowRenderer->clearNeedsTwoPhasesLayout();
}
}
void FlowThreadController::updateFlowThreadsIntoOverflowPhase()
{
for (auto iter = m_renderNamedFlowThreadList->rbegin(), end = m_renderNamedFlowThreadList->rend(); iter != end; ++iter) {
RenderNamedFlowThread* flowRenderer = *iter;
ASSERT(!flowRenderer->hasRegions() || flowRenderer->hasValidRegionInfo());
ASSERT(!flowRenderer->needsTwoPhasesLayout());
flowRenderer->setLayoutPhase(RenderFlowThread::LayoutPhaseConstrained);
flowRenderer->layoutIfNeeded();
flowRenderer->markRegionsForOverflowLayoutIfNeeded();
flowRenderer->setLayoutPhase(RenderFlowThread::LayoutPhaseOverflow);
}
}
void FlowThreadController::updateFlowThreadsIntoMeasureContentPhase()
{
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
ASSERT(flowRenderer->inFinalLayoutPhase());
flowRenderer->dispatchNamedFlowEvents();
flowRenderer->setLayoutPhase(RenderFlowThread::LayoutPhaseMeasureContent);
}
}
void FlowThreadController::updateFlowThreadsIntoFinalPhase()
{
for (auto iter = m_renderNamedFlowThreadList->rbegin(), end = m_renderNamedFlowThreadList->rend(); iter != end; ++iter) {
RenderNamedFlowThread* flowRenderer = *iter;
flowRenderer->layoutIfNeeded();
if (flowRenderer->needsTwoPhasesLayout()) {
flowRenderer->markRegionsForOverflowLayoutIfNeeded();
flowRenderer->clearNeedsTwoPhasesLayout();
}
flowRenderer->setLayoutPhase(RenderFlowThread::LayoutPhaseFinal);
}
}
void FlowThreadController::updateFlowThreadsLayerToRegionMappingsIfNeeded()
{
for (auto& flowRenderer : *m_renderNamedFlowThreadList)
flowRenderer->updateAllLayerToRegionMappingsIfNeeded();
}
void FlowThreadController::updateNamedFlowsLayerListsIfNeeded()
{
for (auto& flowRenderer : *m_renderNamedFlowThreadList)
flowRenderer->layer()->updateLayerListsIfNeeded();
}
static inline bool compareZIndexFlowThreadController(RenderLayer* first, RenderLayer* second)
{
return first->zIndex() < second->zIndex();
}
void FlowThreadController::collectFixedPositionedLayers(Vector<RenderLayer*>& fixedPosLayers) const
{
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
if (!flowRenderer->hasRegions())
continue;
RenderLayer* flowThreadLayer = flowRenderer->layer();
if (Vector<RenderLayer*>* negZOrderList = flowThreadLayer->negZOrderList()) {
for (size_t i = 0, size = negZOrderList->size(); i < size; ++i) {
RenderLayer* currLayer = negZOrderList->at(i);
if (currLayer->renderer().style().position() != FixedPosition)
continue;
fixedPosLayers.append(currLayer);
}
}
if (Vector<RenderLayer*>* posZOrderList = flowThreadLayer->posZOrderList()) {
for (size_t i = 0, size = posZOrderList->size(); i < size; ++i) {
RenderLayer* currLayer = posZOrderList->at(i);
if (currLayer->renderer().style().position() != FixedPosition)
continue;
fixedPosLayers.append(currLayer);
}
}
}
std::stable_sort(fixedPosLayers.begin(), fixedPosLayers.end(), compareZIndexFlowThreadController);
}
#ifndef NDEBUG
bool FlowThreadController::isAutoLogicalHeightRegionsCountConsistent() const
{
if (!hasRenderNamedFlowThreads())
return !hasFlowThreadsWithAutoLogicalHeightRegions();
for (auto& flowRenderer : *m_renderNamedFlowThreadList) {
if (!flowRenderer->isAutoLogicalHeightRegionsCountConsistent())
return false;
}
return true;
}
#endif
}