container_query_evaluator.cc | Explore in Territory

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/css/container_query_evaluator.h"

#include "third_party/blink/public/mojom/use_counter/metrics/web_feature.mojom-blink.h"
#include "third_party/blink/renderer/core/css/container_query.h"
#include "third_party/blink/renderer/core/css/css_container_values.h"
#include "third_party/blink/renderer/core/css/media_values_cached.h"
#include "third_party/blink/renderer/core/css/resolver/match_result.h"
#include "third_party/blink/renderer/core/css/snapped_query_scroll_snapshot.h"
#include "third_party/blink/renderer/core/css/stuck_query_scroll_snapshot.h"
#include "third_party/blink/renderer/core/css/style_change_reason.h"
#include "third_party/blink/renderer/core/css/style_recalc_context.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/dom/flat_tree_traversal.h"
#include "third_party/blink/renderer/core/dom/node_computed_style.h"
#include "third_party/blink/renderer/core/style/computed_style.h"

namespace blink {

namespace {

// Produce PhysicalAxes corresponding to the computed container-type.
// Note that this may be different from the *actually* contained axes
// provided to ContainerChanged, since there are multiple sources of
// applied containment (e.g. the 'contain' property itself).
PhysicalAxes ContainerTypeAxes(const ComputedStyle& style) { … }

bool NameMatches(const ComputedStyle& style,
                 const ContainerSelector& container_selector,
                 const TreeScope* selector_tree_scope) { … }

bool TypeMatches(const ComputedStyle& style,
                 const ContainerSelector& container_selector) { … }

bool Matches(const ComputedStyle& style,
             const ContainerSelector& container_selector,
             const TreeScope* selector_tree_scope) { … }

Element* CachedContainer(Element* starting_element,
                         const ContainerSelector& container_selector,
                         const TreeScope* selector_tree_scope,
                         ContainerSelectorCache& container_selector_cache) { … }

}  // namespace

ContainerQueryEvaluator::ContainerQueryEvaluator(Element& container) { … }

// static
Element* ContainerQueryEvaluator::ParentContainerCandidateElement(
    Element& element) { … }

// static
Element* ContainerQueryEvaluator::FindContainer(
    Element* starting_element,
    const ContainerSelector& container_selector,
    const TreeScope* selector_tree_scope) { … }

bool ContainerQueryEvaluator::EvalAndAdd(
    Element* style_container_candidate,
    const StyleRecalcContext& context,
    const ContainerQuery& query,
    ContainerSelectorCache& container_selector_cache,
    MatchResult& match_result) { … }

std::optional<double> ContainerQueryEvaluator::Width() const { … }

std::optional<double> ContainerQueryEvaluator::Height() const { … }

ContainerQueryEvaluator::Result ContainerQueryEvaluator::Eval(
    const ContainerQuery& container_query) const { … }

bool ContainerQueryEvaluator::EvalAndAdd(const ContainerQuery& query,
                                         Change change,
                                         MatchResult& match_result) { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::SizeContainerChanged(
    PhysicalSize size,
    PhysicalAxes contained_axes) { … }

void ContainerQueryEvaluator::SetPendingSnappedStateFromScrollSnapshot(
    const SnappedQueryScrollSnapshot& snapshot) { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::ApplyScrollState() { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::StickyContainerChanged(
    ContainerStuckPhysical stuck_horizontal,
    ContainerStuckPhysical stuck_vertical) { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::SnapContainerChanged(
    ContainerSnappedFlags snapped) { … }

ContainerQueryEvaluator::Change
ContainerQueryEvaluator::StyleContainerChanged() { … }

void ContainerQueryEvaluator::Trace(Visitor* visitor) const { … }

void ContainerQueryEvaluator::UpdateContainerSize(PhysicalSize size,
                                                  PhysicalAxes contained_axes) { … }

void ContainerQueryEvaluator::UpdateContainerStuck(
    ContainerStuckPhysical stuck_horizontal,
    ContainerStuckPhysical stuck_vertical) { … }

void ContainerQueryEvaluator::UpdateContainerSnapped(
    ContainerSnappedFlags snapped) { … }

void ContainerQueryEvaluator::ClearResults(Change change,
                                           ContainerType container_type) { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::ComputeSizeChange()
    const { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::ComputeStyleChange()
    const { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::ComputeStickyChange()
    const { … }

ContainerQueryEvaluator::Change ContainerQueryEvaluator::ComputeSnapChange()
    const { … }

void ContainerQueryEvaluator::UpdateContainerValuesFromUnitChanges(
    StyleRecalcChange change) { … }

void ContainerQueryEvaluator::MarkFontDirtyIfNeeded(
    const ComputedStyle& old_style,
    const ComputedStyle& new_style) { … }

Element* ContainerQueryEvaluator::ContainerElement() const { … }

}  // namespace blink
chromium/third_party/blink/renderer/core/css/container_query_evaluator.cc
