animation_timelines_test_common.cc | Explore in Territory

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

#include "cc/test/animation_timelines_test_common.h"

#include <utility>

#include "base/containers/contains.h"
#include "base/memory/ptr_util.h"
#include "base/not_fatal_until.h"
#include "cc/animation/animation.h"
#include "cc/animation/animation_events.h"
#include "cc/animation/animation_id_provider.h"
#include "cc/animation/animation_timeline.h"
#include "cc/animation/element_animations.h"
#include "cc/animation/keyframe_effect.h"
#include "cc/paint/filter_operation.h"
#include "cc/paint/filter_operations.h"
#include "cc/trees/property_tree.h"
#include "ui/gfx/geometry/transform.h"

namespace cc {

std::unique_ptr<TestLayer> TestLayer::Create() { … }

TestLayer::TestLayer() { … }

TestLayer::~TestLayer() = default;

void TestLayer::ClearMutatedProperties() { … }

int TestLayer::transform_x() const { … }

int TestLayer::transform_y() const { … }

float TestLayer::brightness() const { … }

float TestLayer::invert() const { … }

TestHostClient::TestHostClient(ThreadInstance thread_instance)
    : … { … }

TestHostClient::~TestHostClient() { … }

void TestHostClient::ClearMutatedProperties() { … }

bool TestHostClient::IsOwnerThread() const { … }
bool TestHostClient::InProtectedSequence() const { … }
void TestHostClient::WaitForProtectedSequenceCompletion() const { … }

bool TestHostClient::IsElementInPropertyTrees(ElementId element_id,
                                              ElementListType list_type) const { … }

void TestHostClient::SetMutatorsNeedCommit() { … }

void TestHostClient::SetMutatorsNeedRebuildPropertyTrees() { … }

void TestHostClient::SetElementFilterMutated(ElementId element_id,
                                             ElementListType list_type,
                                             const FilterOperations& filters) { … }

void TestHostClient::SetElementBackdropFilterMutated(
    ElementId element_id,
    ElementListType list_type,
    const FilterOperations& backdrop_filters) { … }

void TestHostClient::SetElementOpacityMutated(ElementId element_id,
                                              ElementListType list_type,
                                              float opacity) { … }

void TestHostClient::SetElementTransformMutated(
    ElementId element_id,
    ElementListType list_type,
    const gfx::Transform& transform) { … }

void TestHostClient::SetElementScrollOffsetMutated(
    ElementId element_id,
    ElementListType list_type,
    const gfx::PointF& scroll_offset) { … }

void TestHostClient::ElementIsAnimatingChanged(
    const PropertyToElementIdMap& element_id_map,
    ElementListType list_type,
    const PropertyAnimationState& mask,
    const PropertyAnimationState& state) { … }

void TestHostClient::MaximumScaleChanged(ElementId element_id,
                                         ElementListType list_type,
                                         float maximum_scale) { … }

void TestHostClient::SetScrollOffsetForAnimation(
    const gfx::PointF& scroll_offset,
    ElementId element_id) { … }

void TestHostClient::RegisterElementId(ElementId element_id,
                                       ElementListType list_type) { … }

void TestHostClient::UnregisterElementId(ElementId element_id,
                                         ElementListType list_type) { … }

bool TestHostClient::IsPropertyMutated(ElementId element_id,
                                       ElementListType list_type,
                                       TargetProperty::Type property) const { … }

FilterOperations TestHostClient::GetFilters(ElementId element_id,
                                            ElementListType list_type) const { … }

FilterOperations TestHostClient::GetBackdropFilters(
    ElementId element_id,
    ElementListType list_type) const { … }

float TestHostClient::GetOpacity(ElementId element_id,
                                 ElementListType list_type) const { … }

gfx::Transform TestHostClient::GetTransform(ElementId element_id,
                                            ElementListType list_type) const { … }

gfx::PointF TestHostClient::GetScrollOffset(ElementId element_id,
                                            ElementListType list_type) const { … }

bool TestHostClient::GetTransformIsCurrentlyAnimating(
    ElementId element_id,
    ElementListType list_type) const { … }

bool TestHostClient::GetHasPotentialTransformAnimation(
    ElementId element_id,
    ElementListType list_type) const { … }

bool TestHostClient::GetOpacityIsCurrentlyAnimating(
    ElementId element_id,
    ElementListType list_type) const { … }

bool TestHostClient::GetHasPotentialOpacityAnimation(
    ElementId element_id,
    ElementListType list_type) const { … }

bool TestHostClient::GetFilterIsCurrentlyAnimating(
    ElementId element_id,
    ElementListType list_type) const { … }

bool TestHostClient::GetHasPotentialFilterAnimation(
    ElementId element_id,
    ElementListType list_type) const { … }

bool TestHostClient::GetBackdropFilterIsCurrentlyAnimating(
    ElementId element_id,
    ElementListType list_type) const { … }

bool TestHostClient::GetHasPotentialBackdropFilterAnimation(
    ElementId element_id,
    ElementListType list_type) const { … }

void TestHostClient::ExpectFilterPropertyMutated(ElementId element_id,
                                                 ElementListType list_type,
                                                 float brightness) const { … }

void TestHostClient::ExpectBackdropFilterPropertyMutated(
    ElementId element_id,
    ElementListType list_type,
    float invert) const { … }

void TestHostClient::ExpectOpacityPropertyMutated(ElementId element_id,
                                                  ElementListType list_type,
                                                  float opacity) const { … }

void TestHostClient::ExpectTransformPropertyMutated(ElementId element_id,
                                                    ElementListType list_type,
                                                    int transform_x,
                                                    int transform_y) const { … }

bool TestHostClient::RunsOnCurrentThread() const { … }

TestLayer* TestHostClient::FindTestLayer(ElementId element_id,
                                         ElementListType list_type) const { … }

TestAnimationDelegate::TestAnimationDelegate()
    : … { … }

void TestAnimationDelegate::NotifyAnimationStarted(
    base::TimeTicks monotonic_time,
    int target_property,
    int group) { … }

void TestAnimationDelegate::NotifyAnimationFinished(
    base::TimeTicks monotonic_time,
    int target_property,
    int group) { … }

void TestAnimationDelegate::NotifyAnimationAborted(
    base::TimeTicks monotonic_time,
    int target_property,
    int group) { … }

void TestAnimationDelegate::NotifyAnimationTakeover(
    base::TimeTicks monotonic_time,
    int target_property,
    base::TimeTicks animation_start_time,
    std::unique_ptr<gfx::AnimationCurve> curve) { … }

void TestAnimationDelegate::NotifyLocalTimeUpdated(
    std::optional<base::TimeDelta> local_time) { … }

AnimationTimelinesTest::AnimationTimelinesTest()
    : … { … }

AnimationTimelinesTest::~AnimationTimelinesTest() = default;

void AnimationTimelinesTest::SetUp() { … }

void AnimationTimelinesTest::TearDown() { … }

void AnimationTimelinesTest::CreateTestLayer(
    bool needs_active_value_observations,
    bool needs_pending_value_observations) { … }

void AnimationTimelinesTest::CreateTestMainLayer() { … }

void AnimationTimelinesTest::DestroyTestMainLayer() { … }

void AnimationTimelinesTest::CreateTestImplLayer(
    ElementListType element_list_type) { … }

void AnimationTimelinesTest::AttachTimelineAnimationLayer() { … }

void AnimationTimelinesTest::CreateImplTimelineAndAnimation() { … }

void AnimationTimelinesTest::GetImplTimelineAndAnimationByID() { … }

void AnimationTimelinesTest::ReleaseRefPtrs() { … }

void AnimationTimelinesTest::TickAnimationsTransferEvents(
    base::TimeTicks time,
    unsigned expect_events) { … }

KeyframeEffect* AnimationTimelinesTest::GetKeyframeEffectForElementId(
    ElementId element_id) { … }

KeyframeEffect* AnimationTimelinesTest::GetImplKeyframeEffectForLayerId(
    ElementId element_id) { … }

bool AnimationTimelinesTest::CheckKeyframeEffectTimelineNeedsPushProperties(
    bool needs_push_properties) const { … }

void AnimationTimelinesTest::PushProperties() { … }

}  // namespace cc
chromium/cc/test/animation_timelines_test_common.cc
