diff options
Diffstat (limited to 'chromium/cc')
217 files changed, 6476 insertions, 3216 deletions
diff --git a/chromium/cc/BUILD.gn b/chromium/cc/BUILD.gn index deaca4f894b..7e5e837b8e7 100644 --- a/chromium/cc/BUILD.gn +++ b/chromium/cc/BUILD.gn @@ -32,7 +32,6 @@ cc_component("cc") { "input/browser_controls_offset_manager.cc", "input/browser_controls_offset_manager.h", "input/browser_controls_offset_manager_client.h", - "input/input_handler.cc", "input/input_handler.h", "input/layer_selection_bound.cc", "input/layer_selection_bound.h", @@ -49,6 +48,9 @@ cc_component("cc") { "input/scroll_state.h", "input/scroll_state_data.cc", "input/scroll_state_data.h", + "input/scroll_utils.cc", + "input/scroll_utils.h", + "input/scrollbar.h", "input/scrollbar_animation_controller.cc", "input/scrollbar_animation_controller.h", "input/scrollbar_controller.cc", @@ -101,8 +103,6 @@ cc_component("cc") { "layers/painted_scrollbar_layer.h", "layers/painted_scrollbar_layer_impl.cc", "layers/painted_scrollbar_layer_impl.h", - "layers/picture_image_layer.cc", - "layers/picture_image_layer.h", "layers/picture_layer.cc", "layers/picture_layer.h", "layers/picture_layer_impl.cc", @@ -157,6 +157,8 @@ cc_component("cc") { "metrics/compositor_frame_reporting_controller.h", "metrics/compositor_timing_history.cc", "metrics/compositor_timing_history.h", + "metrics/dropped_frame_counter.cc", + "metrics/dropped_frame_counter.h", "metrics/event_metrics.cc", "metrics/event_metrics.h", "metrics/events_metrics_manager.cc", @@ -312,8 +314,6 @@ cc_component("cc") { "trees/draw_property_utils.h", "trees/effect_node.cc", "trees/effect_node.h", - "trees/frame_rate_counter.cc", - "trees/frame_rate_counter.h", "trees/frame_rate_estimator.cc", "trees/frame_rate_estimator.h", "trees/image_animation_controller.cc", @@ -642,7 +642,6 @@ cc_test("cc_unittests") { "layers/painted_overlay_scrollbar_layer_unittest.cc", "layers/painted_scrollbar_layer_impl_unittest.cc", "layers/painted_scrollbar_layer_unittest.cc", - "layers/picture_image_layer_unittest.cc", "layers/picture_layer_impl_unittest.cc", "layers/picture_layer_unittest.cc", "layers/recording_source_unittest.cc", diff --git a/chromium/cc/animation/animation.cc b/chromium/cc/animation/animation.cc index 5c40eed8453..df27dc32d11 100644 --- a/chromium/cc/animation/animation.cc +++ b/chromium/cc/animation/animation.cc @@ -127,20 +127,15 @@ void Animation::Tick(base::TimeTicks tick_time) { // time and then ticks it which side-steps the start time altogether. See // crbug.com/1076012 for alternative design choices considered for future // improvement. - TickWithLocalTime(tick_time - base::TimeTicks()); + keyframe_effect_->Pause(tick_time - base::TimeTicks(), + PauseCondition::kAfterStart); + keyframe_effect_->Tick(base::TimeTicks()); } else { DCHECK(!tick_time.is_null()); keyframe_effect_->Tick(tick_time); } } -void Animation::TickWithLocalTime(base::TimeDelta local_time) { - // TODO(yigu): KeyframeEffect should support ticking KeyframeModel - // directly without using Pause(). https://crbug.com/1076012. - keyframe_effect_->Pause(local_time); - keyframe_effect_->Tick(base::TimeTicks()); -} - bool Animation::IsScrollLinkedAnimation() const { return animation_timeline_ && animation_timeline_->IsScrollTimeline(); } @@ -211,10 +206,6 @@ void Animation::DelegateAnimationEvent(const AnimationEvent& event) { } } -size_t Animation::TickingKeyframeModelsCount() const { - return keyframe_effect_->TickingKeyframeModelsCount(); -} - bool Animation::AffectsCustomProperty() const { return keyframe_effect_->AffectsCustomProperty(); } @@ -287,12 +278,4 @@ void Animation::NotifyKeyframeModelFinishedForTesting( DispatchAndDelegateAnimationEvent(event); } -void Animation::UpdateScrollTimeline(base::Optional<ElementId> scroller_id, - base::Optional<double> start_scroll_offset, - base::Optional<double> end_scroll_offset) { - ToScrollTimeline(animation_timeline_) - ->UpdateScrollerIdAndScrollOffsets(scroller_id, start_scroll_offset, - end_scroll_offset); -} - } // namespace cc diff --git a/chromium/cc/animation/animation.h b/chromium/cc/animation/animation.h index 7fa4136d591..6cc50117d1f 100644 --- a/chromium/cc/animation/animation.h +++ b/chromium/cc/animation/animation.h @@ -65,17 +65,6 @@ class CC_ANIMATION_EXPORT Animation : public base::RefCounted<Animation> { } void SetAnimationTimeline(AnimationTimeline* timeline); - // TODO(yigu): There is a reverse dependency between AnimationTimeline and - // Animation. ScrollTimeline update should be handled by AnimationHost instead - // of Animation. This could be fixed once the snapshotting in blink is - // implemented. https://crbug.com/1023508. - - // Should be called when the ScrollTimeline attached to this animation has a - // change, such as when the scroll source changes ElementId. - void UpdateScrollTimeline(base::Optional<ElementId> scroller_id, - base::Optional<double> start_scroll_offset, - base::Optional<double> end_scroll_offset); - scoped_refptr<ElementAnimations> element_animations() const; void set_animation_delegate(AnimationDelegate* delegate) { @@ -118,7 +107,6 @@ class CC_ANIMATION_EXPORT Animation : public base::RefCounted<Animation> { // to be dispatched. void DispatchAndDelegateAnimationEvent(const AnimationEvent& event); - size_t TickingKeyframeModelsCount() const; bool AffectsCustomProperty() const; void SetNeedsPushProperties(); @@ -151,7 +139,6 @@ class CC_ANIMATION_EXPORT Animation : public base::RefCounted<Animation> { explicit Animation(int id); Animation(int id, std::unique_ptr<KeyframeEffect>); virtual ~Animation(); - void TickWithLocalTime(base::TimeDelta local_time); AnimationHost* animation_host_; AnimationTimeline* animation_timeline_; diff --git a/chromium/cc/animation/animation_delegate.h b/chromium/cc/animation/animation_delegate.h index 0adbb115c59..6931c8b0d18 100644 --- a/chromium/cc/animation/animation_delegate.h +++ b/chromium/cc/animation/animation_delegate.h @@ -13,12 +13,6 @@ namespace cc { class CC_ANIMATION_EXPORT AnimationDelegate { public: - // TODO(yigu): The Notify* methods will be called multiple times per - // animation (once for effect/property pairing). - // Ideally, we would only notify start once (e.g., wait on all effects to - // start before notifying delegate) this way effect becomes an internal - // details of the animation. Perhaps we can do that at some point maybe as - // part of https://bugs.chromium.org/p/chromium/issues/detail?id=810003 virtual void NotifyAnimationStarted(base::TimeTicks monotonic_time, int target_property, int group) = 0; diff --git a/chromium/cc/animation/animation_host.cc b/chromium/cc/animation/animation_host.cc index 1dfe39e66c9..d2154f19594 100644 --- a/chromium/cc/animation/animation_host.cc +++ b/chromium/cc/animation/animation_host.cc @@ -219,6 +219,8 @@ void AnimationHost::SetNeedsCommit() { } void AnimationHost::SetNeedsPushProperties() { + if (needs_push_properties_) + return; needs_push_properties_ = true; if (mutator_host_client_) mutator_host_client_->SetMutatorsNeedCommit(); @@ -227,6 +229,14 @@ void AnimationHost::SetNeedsPushProperties() { void AnimationHost::PushPropertiesTo(MutatorHost* mutator_host_impl) { auto* host_impl = static_cast<AnimationHost*>(mutator_host_impl); + // Update animation counts and whether raf was requested. These explicitly + // do not request push properties and are pushed as part of the next commit + // when it happens as requesting a commit leads to performance issues: + // https://crbug.com/1083244 + host_impl->main_thread_animations_count_ = main_thread_animations_count_; + host_impl->current_frame_had_raf_ = current_frame_had_raf_; + host_impl->next_frame_has_pending_raf_ = next_frame_has_pending_raf_; + if (needs_push_properties_) { needs_push_properties_ = false; PushTimelinesToImplThread(host_impl); @@ -289,9 +299,6 @@ void AnimationHost::PushPropertiesToImplThread(AnimationHost* host_impl) { // Update the impl-only scroll offset animations. scroll_offset_animations_->PushPropertiesTo( host_impl->scroll_offset_animations_impl_.get()); - host_impl->main_thread_animations_count_ = main_thread_animations_count_; - host_impl->current_frame_had_raf_ = current_frame_had_raf_; - host_impl->next_frame_has_pending_raf_ = next_frame_has_pending_raf_; // The pending info list is cleared in LayerTreeHostImpl::CommitComplete // and should be empty when pushing properties. @@ -752,37 +759,25 @@ void AnimationHost::SetMutationUpdate( } } -size_t AnimationHost::CompositedAnimationsCount() const { - size_t composited_animations_count = 0; - for (const auto& it : ticking_animations_) - composited_animations_count += it->TickingKeyframeModelsCount(); - return composited_animations_count; -} - void AnimationHost::SetAnimationCounts( size_t total_animations_count, bool current_frame_had_raf, bool next_frame_has_pending_raf) { + // Though these changes are pushed as part of AnimationHost::PushPropertiesTo + // we don't SetNeedsPushProperties as pushing the values requires a commit. + // Instead we allow them to be pushed whenever the next required commit + // happens to avoid unnecessary work. See https://crbug.com/1083244. + // If an animation is being run on the compositor, it will have a ticking // Animation (which will have a corresponding impl-thread version). Therefore // to find the count of main-only animations, we can simply subtract the // number of ticking animations from the total count. size_t ticking_animations_count = ticking_animations_.size(); - if (main_thread_animations_count_ != - total_animations_count - ticking_animations_count) { - main_thread_animations_count_ = - total_animations_count - ticking_animations_count; - DCHECK_GE(main_thread_animations_count_, 0u); - SetNeedsPushProperties(); - } - if (current_frame_had_raf != current_frame_had_raf_) { - current_frame_had_raf_ = current_frame_had_raf; - SetNeedsPushProperties(); - } - if (next_frame_has_pending_raf != next_frame_has_pending_raf_) { - next_frame_has_pending_raf_ = next_frame_has_pending_raf; - SetNeedsPushProperties(); - } + main_thread_animations_count_ = + total_animations_count - ticking_animations_count; + DCHECK_GE(main_thread_animations_count_, 0u); + current_frame_had_raf_ = current_frame_had_raf; + next_frame_has_pending_raf_ = next_frame_has_pending_raf; } size_t AnimationHost::MainThreadAnimationsCount() const { diff --git a/chromium/cc/animation/animation_host.h b/chromium/cc/animation/animation_host.h index de1ae6f8811..534f8c0c642 100644 --- a/chromium/cc/animation/animation_host.h +++ b/chromium/cc/animation/animation_host.h @@ -207,7 +207,6 @@ class CC_ANIMATION_EXPORT AnimationHost : public MutatorHost, void SetMutationUpdate( std::unique_ptr<MutatorOutputState> output_state) override; - size_t CompositedAnimationsCount() const override; size_t MainThreadAnimationsCount() const override; bool HasCustomPropertyAnimations() const override; bool CurrentFrameHadRAF() const override; diff --git a/chromium/cc/animation/animation_host_unittest.cc b/chromium/cc/animation/animation_host_unittest.cc index c2659983070..4dc4f9905d5 100644 --- a/chromium/cc/animation/animation_host_unittest.cc +++ b/chromium/cc/animation/animation_host_unittest.cc @@ -363,6 +363,9 @@ TEST_F(AnimationHostTest, LayerTreeMutatorUpdateReflectsScrollAnimations) { } TEST_F(AnimationHostTest, TickScrollLinkedAnimation) { + client_.RegisterElementId(element_id_, ElementListType::ACTIVE); + client_impl_.RegisterElementId(element_id_, ElementListType::PENDING); + client_impl_.RegisterElementId(element_id_, ElementListType::ACTIVE); PropertyTrees property_trees; property_trees.is_main_thread = false; property_trees.is_active = true; @@ -378,7 +381,7 @@ TEST_F(AnimationHostTest, TickScrollLinkedAnimation) { scoped_refptr<Animation> animation = Animation::Create(animation_id); host_impl_->AddAnimationTimeline(scroll_timeline); scroll_timeline->AttachAnimation(animation); - animation->AddToTicking(); + ASSERT_TRUE(animation->IsScrollLinkedAnimation()); animation->AttachElement(element_id_); @@ -393,7 +396,7 @@ TEST_F(AnimationHostTest, TickScrollLinkedAnimation) { EXPECT_TRUE(host_impl_->TickAnimations(base::TimeTicks(), property_trees.scroll_tree, false)); - EXPECT_EQ(keyframe_model->run_state(), KeyframeModel::PAUSED); + EXPECT_EQ(keyframe_model->run_state(), KeyframeModel::STARTING); double tick_time = (scroll_timeline->CurrentTime(scroll_tree, false).value() - base::TimeTicks()) .InSecondsF(); diff --git a/chromium/cc/animation/element_animations_unittest.cc b/chromium/cc/animation/element_animations_unittest.cc index 34debd1808a..9e1fa8337f3 100644 --- a/chromium/cc/animation/element_animations_unittest.cc +++ b/chromium/cc/animation/element_animations_unittest.cc @@ -3874,26 +3874,6 @@ TEST_F(ElementAnimationsTest, RemoveAndReAddAnimationToTicking) { EXPECT_EQ(1u, host_->ticking_animations_for_testing().size()); } -TEST_F(ElementAnimationsTest, TickingKeyframeModelsCount) { - CreateTestLayer(false, false); - AttachTimelineAnimationLayer(); - - // Add an animation and ensure the animation is in the host's ticking - // animations. - animation_->AddKeyframeModel(CreateKeyframeModel( - std::unique_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 1.f, 0.5f)), - 2, TargetProperty::OPACITY)); - EXPECT_EQ(1u, animation_->TickingKeyframeModelsCount()); - EXPECT_EQ(1u, host_->CompositedAnimationsCount()); - animation_->AddKeyframeModel(CreateKeyframeModel( - std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1)), 1, - TargetProperty::TRANSFORM)); - EXPECT_EQ(2u, animation_->TickingKeyframeModelsCount()); - EXPECT_EQ(2u, host_->CompositedAnimationsCount()); - animation_->keyframe_effect()->RemoveFromTicking(); - EXPECT_EQ(0u, host_->CompositedAnimationsCount()); -} - // This test verifies that finished keyframe models don't get copied over to // impl thread. TEST_F(ElementAnimationsTest, FinishedKeyframeModelsNotCopiedToImpl) { diff --git a/chromium/cc/animation/keyframe_effect.cc b/chromium/cc/animation/keyframe_effect.cc index 5af52eb211b..710d4f51c13 100644 --- a/chromium/cc/animation/keyframe_effect.cc +++ b/chromium/cc/animation/keyframe_effect.cc @@ -214,14 +214,28 @@ void KeyframeEffect::UpdateTickingState() { } } -void KeyframeEffect::Pause(base::TimeDelta pause_offset) { - for (auto& keyframe_model : keyframe_models_) +void KeyframeEffect::Pause(base::TimeDelta pause_offset, + PauseCondition pause_condition) { + bool did_pause = false; + for (auto& keyframe_model : keyframe_models_) { + // TODO(crbug.com/1076012): KeyframeEffect is paused with local time for + // scroll-linked animations. To make sure the start event of a keyframe + // model is sent to blink, we should not set its run state to PAUSED until + // such event is sent. This should be revisited once KeyframeEffect is able + // to tick scroll-linked keyframe models directly. + if (pause_condition == PauseCondition::kAfterStart && + (keyframe_model->run_state() == + KeyframeModel::WAITING_FOR_TARGET_AVAILABILITY || + keyframe_model->run_state() == KeyframeModel::STARTING)) + continue; keyframe_model->Pause(pause_offset); - - if (has_bound_element_animations()) { - animation_->SetNeedsCommit(); - SetNeedsPushProperties(); + did_pause = true; } + + if (!did_pause || !has_bound_element_animations()) + return; + animation_->SetNeedsCommit(); + SetNeedsPushProperties(); } void KeyframeEffect::AddKeyframeModel( @@ -458,14 +472,6 @@ bool KeyframeEffect::HasTickingKeyframeModel() const { return false; } -size_t KeyframeEffect::TickingKeyframeModelsCount() const { - size_t ticking_keyframe_models_count = 0; - for (const auto& it : keyframe_models_) - if (!it->is_finished()) - ticking_keyframe_models_count++; - return ticking_keyframe_models_count; -} - bool KeyframeEffect::AffectsCustomProperty() const { for (const auto& it : keyframe_models_) if (it->target_property_id() == TargetProperty::CSS_CUSTOM_PROPERTY) diff --git a/chromium/cc/animation/keyframe_effect.h b/chromium/cc/animation/keyframe_effect.h index e7806e4cc1d..0e1280f82e1 100644 --- a/chromium/cc/animation/keyframe_effect.h +++ b/chromium/cc/animation/keyframe_effect.h @@ -22,6 +22,7 @@ namespace cc { class Animation; +enum class PauseCondition { kUnconditional, kAfterStart }; struct PropertyAnimationState; // A KeyframeEffect owns a group of KeyframeModels for a single target @@ -86,7 +87,8 @@ class CC_ANIMATION_EXPORT KeyframeEffect { void UpdateState(bool start_ready_keyframe_models, AnimationEvents* events); void UpdateTickingState(); - void Pause(base::TimeDelta pause_offset); + void Pause(base::TimeDelta pause_offset, + PauseCondition = PauseCondition::kUnconditional); void AddKeyframeModel(std::unique_ptr<KeyframeModel> keyframe_model); void PauseKeyframeModel(int keyframe_model_id, base::TimeDelta time_offset); @@ -106,7 +108,6 @@ class CC_ANIMATION_EXPORT KeyframeEffect { // Returns true if there are any KeyframeModels that have neither finished // nor aborted. bool HasTickingKeyframeModel() const; - size_t TickingKeyframeModelsCount() const; bool AffectsCustomProperty() const; diff --git a/chromium/cc/animation/keyframe_model.cc b/chromium/cc/animation/keyframe_model.cc index 25e2c6d232b..bb779226080 100644 --- a/chromium/cc/animation/keyframe_model.cc +++ b/chromium/cc/animation/keyframe_model.cc @@ -156,7 +156,7 @@ void KeyframeModel::SetRunState(RunState run_state, void KeyframeModel::Pause(base::TimeDelta pause_offset) { // Convert pause offset which is in local time to monotonic time. - // TODO(yigu): This should be scaled by playbackrate. http://crbug.com/912407 + // TODO(crbug.com/912407): This should be scaled by playbackrate. base::TimeTicks monotonic_time = pause_offset + start_time_ + total_paused_duration_; SetRunState(PAUSED, monotonic_time); @@ -246,8 +246,7 @@ bool KeyframeModel::InEffect(base::TimeTicks monotonic_time) const { return CalculateActiveTime(monotonic_time).has_value(); } -// TODO(yigu): Local time should be scaled by playback rate by spec. -// https://crbug.com/912407. +// TODO(crbug.com/912407): Local time should be scaled by playback rate by spec. base::TimeDelta KeyframeModel::ConvertMonotonicTimeToLocalTime( base::TimeTicks monotonic_time) const { // When waiting on receiving a start time, then our global clock is 'stuck' at diff --git a/chromium/cc/animation/transform_operations.h b/chromium/cc/animation/transform_operations.h index 2fecd424325..f0c669cf3e7 100644 --- a/chromium/cc/animation/transform_operations.h +++ b/chromium/cc/animation/transform_operations.h @@ -9,8 +9,8 @@ #include <unordered_map> #include <vector> +#include "base/check_op.h" #include "base/gtest_prod_util.h" -#include "base/logging.h" #include "cc/animation/animation_export.h" #include "cc/animation/transform_operation.h" #include "ui/gfx/transform.h" diff --git a/chromium/cc/animation/worklet_animation.cc b/chromium/cc/animation/worklet_animation.cc index 17ed083efcc..fd9a9c700ea 100644 --- a/chromium/cc/animation/worklet_animation.cc +++ b/chromium/cc/animation/worklet_animation.cc @@ -92,7 +92,8 @@ void WorkletAnimation::Tick(base::TimeTicks monotonic_time) { // animations lifecycle. To avoid this we pause the underlying keyframe effect // at the local time obtained from the user script - essentially turning each // call to |WorkletAnimation::Tick| into a seek in the effect. - TickWithLocalTime(local_time_.value()); + keyframe_effect_->Pause(local_time_.value()); + keyframe_effect_->Tick(base::TimeTicks()); } void WorkletAnimation::UpdateState(bool start_ready_animations, @@ -162,10 +163,6 @@ void WorkletAnimation::UpdateInputState(MutatorInputState* input_state, switch (state_) { case State::PENDING: - // TODO(yigu): cc side WorkletAnimation is only capable of handling single - // keyframe effect at the moment. We should pass in the number of effects - // once Worklet Group Effect is fully implemented in cc. - // https://crbug.com/767043. input_state->Add({worklet_animation_id(), name(), current_time->InMillisecondsF(), CloneOptions(), CloneEffectTimings()}); @@ -186,8 +183,6 @@ void WorkletAnimation::UpdateInputState(MutatorInputState* input_state, void WorkletAnimation::SetOutputState( const MutatorOutputState::AnimationState& state) { - // TODO(yigu): cc side WorkletAnimation is only capable of handling single - // keyframe effect at the moment. https://crbug.com/767043. DCHECK_EQ(state.local_times.size(), 1u); local_time_ = state.local_times[0]; } diff --git a/chromium/cc/animation/worklet_animation_unittest.cc b/chromium/cc/animation/worklet_animation_unittest.cc index e827c3740e3..ed610a56c19 100644 --- a/chromium/cc/animation/worklet_animation_unittest.cc +++ b/chromium/cc/animation/worklet_animation_unittest.cc @@ -555,20 +555,6 @@ TEST_F(WorkletAnimationTest, SkipLockedAnimations) { EXPECT_EQ(input->updated_animations.size(), 1u); } -TEST_F(WorkletAnimationTest, UpdateScrollTimelineScrollerId) { - auto scroll_timeline = base::WrapRefCounted(new MockScrollTimeline()); - EXPECT_EQ(scroll_timeline->GetPendingIdForTest(), ElementId()); - - scoped_refptr<WorkletAnimation> worklet_animation = WorkletAnimation::Create( - worklet_animation_id_, "test_name", 1, nullptr, nullptr); - host_->AddAnimationTimeline(scroll_timeline); - scroll_timeline->AttachAnimation(worklet_animation); - ElementId scroller_id = ElementId(1); - worklet_animation->UpdateScrollTimeline(scroller_id, base::nullopt, - base::nullopt); - EXPECT_EQ(scroll_timeline->GetPendingIdForTest(), scroller_id); -} - } // namespace } // namespace cc diff --git a/chromium/cc/base/completion_event.h b/chromium/cc/base/completion_event.h index 5c9debd64f4..f5084d5346c 100644 --- a/chromium/cc/base/completion_event.h +++ b/chromium/cc/base/completion_event.h @@ -5,7 +5,7 @@ #ifndef CC_BASE_COMPLETION_EVENT_H_ #define CC_BASE_COMPLETION_EVENT_H_ -#include "base/logging.h" +#include "base/check.h" #include "base/synchronization/waitable_event.h" #include "base/threading/thread_restrictions.h" #include "base/time/time.h" diff --git a/chromium/cc/base/devtools_instrumentation.cc b/chromium/cc/base/devtools_instrumentation.cc index 72b7be7a999..b386c7527c7 100644 --- a/chromium/cc/base/devtools_instrumentation.cc +++ b/chromium/cc/base/devtools_instrumentation.cc @@ -66,23 +66,34 @@ ScopedImageUploadTask::~ScopedImageUploadTask() { return; auto duration = base::TimeTicks::Now() - start_time_; + const char* histogram_name = nullptr; switch (image_type_) { - case ImageType::kWebP: - UmaHistogramCustomMicrosecondsTimes( - "Renderer4.ImageUploadTaskDurationUs.WebP", duration, hist_min_, - hist_max_, bucket_count_); + case ImageType::kAvif: + histogram_name = "Renderer4.ImageUploadTaskDurationUs.Avif"; + break; + case ImageType::kBmp: + histogram_name = "Renderer4.ImageUploadTaskDurationUs.Bmp"; + break; + case ImageType::kGif: + histogram_name = "Renderer4.ImageUploadTaskDurationUs.Gif"; + break; + case ImageType::kIco: + histogram_name = "Renderer4.ImageUploadTaskDurationUs.Ico"; break; case ImageType::kJpeg: - UmaHistogramCustomMicrosecondsTimes( - "Renderer4.ImageUploadTaskDurationUs.Jpeg", duration, hist_min_, - hist_max_, bucket_count_); + histogram_name = "Renderer4.ImageUploadTaskDurationUs.Jpeg"; break; - case ImageType::kOther: - UmaHistogramCustomMicrosecondsTimes( - "Renderer4.ImageUploadTaskDurationUs.Other", duration, hist_min_, - hist_max_, bucket_count_); + case ImageType::kPng: + histogram_name = "Renderer4.ImageUploadTaskDurationUs.Png"; break; + case ImageType::kWebP: + histogram_name = "Renderer4.ImageUploadTaskDurationUs.WebP"; + break; + case ImageType::kOther: + histogram_name = "Renderer4.ImageUploadTaskDurationUs.Other"; } + UmaHistogramCustomMicrosecondsTimes(histogram_name, duration, hist_min_, + hist_max_, bucket_count_); } ScopedImageDecodeTask::ScopedImageDecodeTask(const void* image_ptr, @@ -104,23 +115,36 @@ ScopedImageDecodeTask::~ScopedImageDecodeTask() { return; auto duration = base::TimeTicks::Now() - start_time_; + const char* histogram_name = nullptr; switch (image_type_) { - case ImageType::kWebP: - RecordMicrosecondTimesUmaByDecodeType( - "Renderer4.ImageDecodeTaskDurationUs.WebP", duration, hist_min_, - hist_max_, bucket_count_, decode_type_); + case ImageType::kAvif: + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.Avif"; + break; + case ImageType::kBmp: + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.Bmp"; + break; + case ImageType::kGif: + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.Gif"; + break; + case ImageType::kIco: + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.Ico"; break; case ImageType::kJpeg: - RecordMicrosecondTimesUmaByDecodeType( - "Renderer4.ImageDecodeTaskDurationUs.Jpeg", duration, hist_min_, - hist_max_, bucket_count_, decode_type_); + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.Jpeg"; + break; + case ImageType::kPng: + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.Png"; + break; + case ImageType::kWebP: + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.WebP"; break; case ImageType::kOther: - RecordMicrosecondTimesUmaByDecodeType( - "Renderer4.ImageDecodeTaskDurationUs.Other", duration, hist_min_, - hist_max_, bucket_count_, decode_type_); + histogram_name = "Renderer4.ImageDecodeTaskDurationUs.Other"; break; } + RecordMicrosecondTimesUmaByDecodeType(histogram_name, duration, hist_min_, + hist_max_, bucket_count_, decode_type_); + switch (task_type_) { case kInRaster: RecordMicrosecondTimesUmaByDecodeType( diff --git a/chromium/cc/base/devtools_instrumentation.h b/chromium/cc/base/devtools_instrumentation.h index 12e4c9c7016..8c2fd998669 100644 --- a/chromium/cc/base/devtools_instrumentation.h +++ b/chromium/cc/base/devtools_instrumentation.h @@ -66,9 +66,9 @@ class CC_BASE_EXPORT ScopedLayerTask { class CC_BASE_EXPORT ScopedImageTask { public: - enum ImageType { kWebP, kJpeg, kOther }; + enum ImageType { kAvif, kBmp, kGif, kIco, kJpeg, kPng, kWebP, kOther }; - ScopedImageTask(ImageType image_type) + explicit ScopedImageTask(ImageType image_type) : image_type_(image_type), start_time_(base::TimeTicks::Now()) {} ScopedImageTask(const ScopedImageTask&) = delete; ~ScopedImageTask() = default; diff --git a/chromium/cc/base/features.cc b/chromium/cc/base/features.cc index 8c0c599f83d..5c230565fd2 100644 --- a/chromium/cc/base/features.cc +++ b/chromium/cc/base/features.cc @@ -12,6 +12,10 @@ namespace features { const base::Feature kImpulseScrollAnimations = { "ImpulseScrollAnimations", base::FEATURE_DISABLED_BY_DEFAULT}; +// Whether the compositor should attempt to sync with the scroll handlers before submitting a frame. +const base::Feature kSynchronizedScrolling = {"SynchronizedScrolling", + base::FEATURE_ENABLED_BY_DEFAULT}; + // When enabled BeginMainFrame does not wait for activation in the compositor // thread for texture layers (crbug.com/1046463) const base::Feature kTextureLayerSkipWaitForActivation{ diff --git a/chromium/cc/base/features.h b/chromium/cc/base/features.h index 56c620c6eea..ea86ee616d8 100644 --- a/chromium/cc/base/features.h +++ b/chromium/cc/base/features.h @@ -12,6 +12,7 @@ namespace features { CC_BASE_EXPORT extern const base::Feature kImpulseScrollAnimations; +CC_BASE_EXPORT extern const base::Feature kSynchronizedScrolling; CC_BASE_EXPORT extern const base::Feature kTextureLayerSkipWaitForActivation; #if !defined(OS_ANDROID) diff --git a/chromium/cc/base/list_container.h b/chromium/cc/base/list_container.h index 27ba06b9192..a01d07958dd 100644 --- a/chromium/cc/base/list_container.h +++ b/chromium/cc/base/list_container.h @@ -9,7 +9,7 @@ #include <memory> -#include "base/logging.h" +#include "base/check.h" #include "base/optional.h" #include "cc/base/list_container_helper.h" diff --git a/chromium/cc/base/list_container_helper.cc b/chromium/cc/base/list_container_helper.cc index afd386e3a88..7b594b4a458 100644 --- a/chromium/cc/base/list_container_helper.cc +++ b/chromium/cc/base/list_container_helper.cc @@ -7,6 +7,7 @@ #include <stddef.h> #include <algorithm> +#include <cstring> #include <vector> #include "base/check_op.h" diff --git a/chromium/cc/base/math_util.h b/chromium/cc/base/math_util.h index 1001124d9af..a5f30e02252 100644 --- a/chromium/cc/base/math_util.h +++ b/chromium/cc/base/math_util.h @@ -9,7 +9,7 @@ #include <memory> #include <vector> -#include "base/logging.h" +#include "base/check.h" #include "base/numerics/ranges.h" #include "build/build_config.h" #include "cc/base/base_export.h" diff --git a/chromium/cc/base/reverse_spiral_iterator.h b/chromium/cc/base/reverse_spiral_iterator.h index 3fef364871d..1d07381e62d 100644 --- a/chromium/cc/base/reverse_spiral_iterator.h +++ b/chromium/cc/base/reverse_spiral_iterator.h @@ -5,7 +5,6 @@ #ifndef CC_BASE_REVERSE_SPIRAL_ITERATOR_H_ #define CC_BASE_REVERSE_SPIRAL_ITERATOR_H_ -#include "base/logging.h" #include "cc/base/base_export.h" #include "cc/base/index_rect.h" diff --git a/chromium/cc/base/rtree.h b/chromium/cc/base/rtree.h index 2ee4e7cb588..9e92f955de4 100644 --- a/chromium/cc/base/rtree.h +++ b/chromium/cc/base/rtree.h @@ -13,7 +13,7 @@ #include <map> #include <vector> -#include "base/logging.h" +#include "base/check_op.h" #include "base/numerics/clamped_math.h" #include "ui/gfx/geometry/rect.h" diff --git a/chromium/cc/base/spiral_iterator.h b/chromium/cc/base/spiral_iterator.h index af64b76afde..3ed081688e7 100644 --- a/chromium/cc/base/spiral_iterator.h +++ b/chromium/cc/base/spiral_iterator.h @@ -5,7 +5,6 @@ #ifndef CC_BASE_SPIRAL_ITERATOR_H_ #define CC_BASE_SPIRAL_ITERATOR_H_ -#include "base/logging.h" #include "cc/base/base_export.h" #include "cc/base/index_rect.h" diff --git a/chromium/cc/base/switches.h b/chromium/cc/base/switches.h index 7b6c6b398e0..12615d5dcdc 100644 --- a/chromium/cc/base/switches.h +++ b/chromium/cc/base/switches.h @@ -7,7 +7,7 @@ #ifndef CC_BASE_SWITCHES_H_ #define CC_BASE_SWITCHES_H_ -#include "base/logging.h" +#include "base/check.h" #include "cc/base/base_export.h" // Since cc is used from the render process, anything that goes here also needs diff --git a/chromium/cc/base/tiling_data.h b/chromium/cc/base/tiling_data.h index a8b9ee7ec6c..ac294ac5ad6 100644 --- a/chromium/cc/base/tiling_data.h +++ b/chromium/cc/base/tiling_data.h @@ -7,7 +7,7 @@ #include <utility> -#include "base/logging.h" +#include "base/check_op.h" #include "cc/base/base_export.h" #include "cc/base/index_rect.h" #include "cc/base/reverse_spiral_iterator.h" diff --git a/chromium/cc/input/browser_controls_offset_manager.cc b/chromium/cc/input/browser_controls_offset_manager.cc index ea4c6e27993..5ebc925c1e6 100644 --- a/chromium/cc/input/browser_controls_offset_manager.cc +++ b/chromium/cc/input/browser_controls_offset_manager.cc @@ -207,17 +207,20 @@ void BrowserControlsOffsetManager::OnBrowserControlsParamsChanged( return; } + // We continue to update both top and bottom controls even if one has a height + // of 0 so that animations work properly. So here, we should preserve the + // ratios even if the controls height is 0. float old_top_height = old_browser_controls_params_.top_controls_height; float new_top_ratio = TopControlsHeight() ? TopControlsShownRatio() * old_top_height / TopControlsHeight() - : 0.f; + : TopControlsShownRatio(); float old_bottom_height = old_browser_controls_params_.bottom_controls_height; float new_bottom_ratio = BottomControlsHeight() ? BottomControlsShownRatio() * old_bottom_height / BottomControlsHeight() - : 0.f; + : BottomControlsShownRatio(); if (!animate_changes) { // If the min-heights changed when the controls were at the min-height, the @@ -268,8 +271,13 @@ void BrowserControlsOffsetManager::OnBrowserControlsParamsChanged( bool bottom_controls_need_animation = animate_changes; float top_target_ratio; - // If the top controls height changed when they were fully shown. - if (TopControlsShownRatio() == 1.f && TopControlsHeight() != old_top_height) { + // We can't animate if we don't have top controls. + if (!TopControlsHeight()) { + top_controls_need_animation = false; + + // If the top controls height changed when they were fully shown. + } else if (TopControlsShownRatio() == 1.f && + TopControlsHeight() != old_top_height) { top_target_ratio = 1.f; // i.e. new_height / new_height // If the top controls min-height changed when they were at the minimum @@ -284,9 +292,13 @@ void BrowserControlsOffsetManager::OnBrowserControlsParamsChanged( } float bottom_target_ratio; - // If the bottom controls height changed when they were fully shown. - if (BottomControlsShownRatio() == 1.f && - BottomControlsHeight() != old_bottom_height) { + // We can't animate if we don't have bottom controls. + if (!BottomControlsHeight()) { + bottom_controls_need_animation = false; + + // If the bottom controls height changed when they were fully shown. + } else if (BottomControlsShownRatio() == 1.f && + BottomControlsHeight() != old_bottom_height) { bottom_target_ratio = 1.f; // i.e. new_height / new_height // If the bottom controls min-height changed when they were at the minimum diff --git a/chromium/cc/input/browser_controls_offset_manager_unittest.cc b/chromium/cc/input/browser_controls_offset_manager_unittest.cc index 8c443fd0bee..507ca1f3a5a 100644 --- a/chromium/cc/input/browser_controls_offset_manager_unittest.cc +++ b/chromium/cc/input/browser_controls_offset_manager_unittest.cc @@ -1087,5 +1087,61 @@ TEST(BrowserControlsOffsetManagerTest, ScrollWithMinHeightSetForBothControls) { manager->ScrollEnd(); } +TEST(BrowserControlsOffsetManagerTest, ChangingBottomHeightFromZeroAnimates) { + MockBrowserControlsOffsetManagerClient client(100, 0.5f, 0.5f); + client.SetBrowserControlsParams({100, 30, 0, 0, false, false}); + BrowserControlsOffsetManager* manager = client.manager(); + EXPECT_FLOAT_EQ(1.f, client.CurrentTopControlsShownRatio()); + EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio()); + + // Set the bottom controls height to 100 with animation. + client.SetBrowserControlsParams({100, 30, 100, 0, true, false}); + EXPECT_TRUE(manager->HasAnimation()); + // The bottom controls should be hidden in the beginning. + EXPECT_FLOAT_EQ(0.f, manager->ContentBottomOffset()); + EXPECT_FLOAT_EQ(0.f, client.CurrentBottomControlsShownRatio()); + + base::TimeTicks time = base::TimeTicks::Now(); + + // First animate will establish the animaion. + float previous_ratio = manager->BottomControlsShownRatio(); + manager->Animate(time); + EXPECT_EQ(manager->BottomControlsShownRatio(), previous_ratio); + + while (manager->HasAnimation()) { + previous_ratio = manager->BottomControlsShownRatio(); + time = base::TimeDelta::FromMicroseconds(100) + time; + manager->Animate(time); + EXPECT_GT(manager->BottomControlsShownRatio(), previous_ratio); + } + + // Now the bottom controls should be fully shown. + EXPECT_FLOAT_EQ(100.f, manager->ContentBottomOffset()); + EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio()); +} + +TEST(BrowserControlsOffsetManagerTest, + ChangingControlsHeightToZeroWithAnimationIsNoop) { + MockBrowserControlsOffsetManagerClient client(100, 0.5f, 0.5f); + client.SetBrowserControlsParams({100, 20, 80, 10, false, false}); + BrowserControlsOffsetManager* manager = client.manager(); + EXPECT_FLOAT_EQ(1.f, client.CurrentTopControlsShownRatio()); + EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio()); + + // Set the bottom controls height to 0 with animation. + client.SetBrowserControlsParams({100, 20, 0, 0, true, false}); + + // There shouldn't be an animation because we can't animate controls with 0 + // height. + EXPECT_FALSE(manager->HasAnimation()); + // Also, the bottom controls ratio should stay the same. + EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio()); + + // Increase the top controls height with animation. + client.SetBrowserControlsParams({120, 20, 0, 0, true, false}); + // This shouldn't override the bottom controls shown ratio. + EXPECT_FLOAT_EQ(1.f, client.CurrentBottomControlsShownRatio()); +} + } // namespace } // namespace cc diff --git a/chromium/cc/input/input_handler.cc b/chromium/cc/input/input_handler.cc deleted file mode 100644 index 55ca46ef2c0..00000000000 --- a/chromium/cc/input/input_handler.cc +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright 2014 The Chromium 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 "cc/input/input_handler.h" - -namespace cc { - -InputHandlerScrollResult::InputHandlerScrollResult() - : did_scroll(false), did_overscroll_root(false) { -} - -InputHandlerPointerResult::InputHandlerPointerResult() - : type(kUnhandled), - scroll_units(ui::ScrollGranularity::kScrollByPrecisePixel) {} - -} // namespace cc diff --git a/chromium/cc/input/input_handler.h b/chromium/cc/input/input_handler.h index eaaa9afde45..43309848b23 100644 --- a/chromium/cc/input/input_handler.h +++ b/chromium/cc/input/input_handler.h @@ -50,13 +50,14 @@ enum class ScrollBeginThreadState { }; struct CC_EXPORT InputHandlerPointerResult { - InputHandlerPointerResult(); + InputHandlerPointerResult() = default; // Tells what type of processing occurred in the input handler as a result of // the pointer event. - PointerResultType type; + PointerResultType type = kUnhandled; // Tells what scroll_units should be used. - ui::ScrollGranularity scroll_units; + ui::ScrollGranularity scroll_units = + ui::ScrollGranularity::kScrollByPrecisePixel; // If the input handler processed the event as a scrollbar scroll, it will // return a gfx::ScrollOffset that produces the necessary scroll. However, @@ -73,11 +74,11 @@ struct CC_EXPORT InputHandlerPointerResult { }; struct CC_EXPORT InputHandlerScrollResult { - InputHandlerScrollResult(); + InputHandlerScrollResult() = default; // Did any layer scroll as a result this ScrollUpdate call? - bool did_scroll; + bool did_scroll = false; // Was any of the scroll delta argument to this ScrollUpdate call not used? - bool did_overscroll_root; + bool did_overscroll_root = false; // The total overscroll that has been accumulated by all ScrollUpdate calls // that have had overscroll since the last ScrollBegin call. This resets upon // a ScrollUpdate with no overscroll. @@ -139,17 +140,25 @@ class CC_EXPORT InputHandler { InputHandler& operator=(const InputHandler&) = delete; struct ScrollStatus { - ScrollStatus() - : thread(SCROLL_ON_IMPL_THREAD), - main_thread_scrolling_reasons( - MainThreadScrollingReason::kNotScrollingOnMain), - bubble(false) {} + ScrollStatus() = default; ScrollStatus(ScrollThread thread, uint32_t main_thread_scrolling_reasons) : thread(thread), main_thread_scrolling_reasons(main_thread_scrolling_reasons) {} - ScrollThread thread; - uint32_t main_thread_scrolling_reasons; - bool bubble; + ScrollStatus(ScrollThread thread, + uint32_t main_thread_scrolling_reasons, + bool needs_main_thread_hit_test) + : thread(thread), + main_thread_scrolling_reasons(main_thread_scrolling_reasons), + needs_main_thread_hit_test(needs_main_thread_hit_test) {} + ScrollThread thread = SCROLL_ON_IMPL_THREAD; + uint32_t main_thread_scrolling_reasons = + MainThreadScrollingReason::kNotScrollingOnMain; + bool bubble = false; + + // Used only in scroll unification. Tells the caller that the input handler + // detected a case where it cannot reliably target a scroll node and needs + // the main thread to perform a hit test. + bool needs_main_thread_hit_test = false; }; enum class TouchStartOrMoveEventListenerType { @@ -256,7 +265,7 @@ class CC_EXPORT InputHandler { // suppress scrolling by consuming touch events that started at // |viewport_point|, and whether |viewport_point| is on the currently // scrolling layer. - // |out_touch_action| is assigned the whitelisted touch action for the + // |out_touch_action| is assigned the allowed touch action for the // |viewport_point|. In the case there are no touch handlers or touch action // regions, |out_touch_action| is assigned TouchAction::kAuto since the // default touch action is auto. diff --git a/chromium/cc/input/main_thread_scrolling_reason.cc b/chromium/cc/input/main_thread_scrolling_reason.cc index b84c31dd04c..a116970e49b 100644 --- a/chromium/cc/input/main_thread_scrolling_reason.cc +++ b/chromium/cc/input/main_thread_scrolling_reason.cc @@ -44,14 +44,10 @@ void MainThreadScrollingReason::AddToTracedValue( traced_value.AppendString("Handling scroll from main thread"); if (reasons & kHasTransformAndLCDText) traced_value.AppendString("Has transform and LCD text"); - if (reasons & kBackgroundNotOpaqueInRectAndLCDText) - traced_value.AppendString("Background is not opaque in rect and LCD text"); - if (reasons & kCantPaintScrollingBackground) - traced_value.AppendString("Can't paint scrolling background"); - if (reasons & kHasClipRelatedProperty) - traced_value.AppendString("Has clip related property"); - if (reasons & kIsNotStackingContextAndLCDText) - traced_value.AppendString("Is not stacking context and LCD text"); + if (reasons & kNotOpaqueForTextAndLCDText) + traced_value.AppendString("Not opaque for text and LCD text"); + if (reasons & kCantPaintScrollingBackgroundAndLCDText) + traced_value.AppendString("Can't paint scrolling background and LCD text"); // Transient scrolling reasons. if (reasons & kNonFastScrollableRegion) diff --git a/chromium/cc/input/main_thread_scrolling_reason.h b/chromium/cc/input/main_thread_scrolling_reason.h index cd129cf69fc..8354bbb401d 100644 --- a/chromium/cc/input/main_thread_scrolling_reason.h +++ b/chromium/cc/input/main_thread_scrolling_reason.h @@ -44,10 +44,8 @@ struct CC_EXPORT MainThreadScrollingReason { // screen position; transparency and transforms break this. kNonCompositedReasonsFirst = 17, kHasTransformAndLCDText = 1 << 17, - kBackgroundNotOpaqueInRectAndLCDText = 1 << 18, - kCantPaintScrollingBackground = 1 << 19, - kHasClipRelatedProperty = 1 << 20, - kIsNotStackingContextAndLCDText = 1 << 22, + kNotOpaqueForTextAndLCDText = 1 << 18, + kCantPaintScrollingBackgroundAndLCDText = 1 << 19, kNonCompositedReasonsLast = 22, // Transient scrolling reasons. These are computed for each scroll begin. @@ -69,9 +67,8 @@ struct CC_EXPORT MainThreadScrollingReason { }; static const uint32_t kNonCompositedReasons = - kHasTransformAndLCDText | kBackgroundNotOpaqueInRectAndLCDText | - kCantPaintScrollingBackground | kHasClipRelatedProperty | - kIsNotStackingContextAndLCDText; + kHasTransformAndLCDText | kNotOpaqueForTextAndLCDText | + kCantPaintScrollingBackgroundAndLCDText; // Returns true if the given MainThreadScrollingReason can be set by the main // thread. diff --git a/chromium/cc/input/main_thread_scrolling_reason_unittest.cc b/chromium/cc/input/main_thread_scrolling_reason_unittest.cc index 7cf3f40d164..4f8b75516af 100644 --- a/chromium/cc/input/main_thread_scrolling_reason_unittest.cc +++ b/chromium/cc/input/main_thread_scrolling_reason_unittest.cc @@ -20,10 +20,8 @@ TEST_F(MainThreadScrollingReasonTest, AsText) { "Frame overlay, " "Handling scroll from main thread, " "Has transform and LCD text, " - "Background is not opaque in rect and LCD text, " - "Can't paint scrolling background, " - "Has clip related property, " - "Is not stacking context and LCD text, " + "Not opaque for text and LCD text, " + "Can't paint scrolling background and LCD text, " "Non fast scrollable region, " "Failed hit test, " "No scrolling layer, " diff --git a/chromium/cc/input/scroll_elasticity_helper.cc b/chromium/cc/input/scroll_elasticity_helper.cc index 739daaa72a3..451bfcd81ba 100644 --- a/chromium/cc/input/scroll_elasticity_helper.cc +++ b/chromium/cc/input/scroll_elasticity_helper.cc @@ -18,6 +18,7 @@ class ScrollElasticityHelperImpl : public ScrollElasticityHelper { bool IsUserScrollable() const override; gfx::Vector2dF StretchAmount() const override; + gfx::Size ScrollBounds() const override; void SetStretchAmount(const gfx::Vector2dF& stretch_amount) override; gfx::ScrollOffset ScrollOffset() const override; gfx::ScrollOffset MaxScrollOffset() const override; @@ -46,6 +47,12 @@ gfx::Vector2dF ScrollElasticityHelperImpl::StretchAmount() const { return host_impl_->active_tree()->elastic_overscroll()->Current(true); } +gfx::Size ScrollElasticityHelperImpl::ScrollBounds() const { + return host_impl_->OuterViewportScrollNode() + ? host_impl_->OuterViewportScrollNode()->container_bounds + : gfx::Size(); +} + void ScrollElasticityHelperImpl::SetStretchAmount( const gfx::Vector2dF& stretch_amount) { if (stretch_amount == StretchAmount()) diff --git a/chromium/cc/input/scroll_elasticity_helper.h b/chromium/cc/input/scroll_elasticity_helper.h index 81281310ecb..4ae282fe51b 100644 --- a/chromium/cc/input/scroll_elasticity_helper.h +++ b/chromium/cc/input/scroll_elasticity_helper.h @@ -8,6 +8,7 @@ #include "base/time/time.h" #include "cc/cc_export.h" #include "ui/gfx/geometry/scroll_offset.h" +#include "ui/gfx/geometry/size.h" #include "ui/gfx/geometry/vector2d_f.h" namespace cc { @@ -54,6 +55,9 @@ class CC_EXPORT ScrollElasticityHelper { virtual bool IsUserScrollable() const = 0; + // The bounds of the root scroller. + virtual gfx::Size ScrollBounds() const = 0; + // The amount that the view is stretched past the normal allowable bounds. virtual gfx::Vector2dF StretchAmount() const = 0; virtual void SetStretchAmount(const gfx::Vector2dF& stretch_amount) = 0; diff --git a/chromium/cc/input/scroll_state.h b/chromium/cc/input/scroll_state.h index a73b9b117c4..8ac3850ca51 100644 --- a/chromium/cc/input/scroll_state.h +++ b/chromium/cc/input/scroll_state.h @@ -86,6 +86,14 @@ class CC_EXPORT ScrollState { // it's a scroll update gfx::ScrollOffset DeltaOrHint() const; + ElementId target_element_id() const { + return data_.current_native_scrolling_element(); + } + + bool is_main_thread_hit_tested() const { + return data_.is_main_thread_hit_tested; + } + ScrollStateData* data() { return &data_; } private: diff --git a/chromium/cc/input/scroll_state_data.cc b/chromium/cc/input/scroll_state_data.cc index 4c472790f15..f18676f4b85 100644 --- a/chromium/cc/input/scroll_state_data.cc +++ b/chromium/cc/input/scroll_state_data.cc @@ -25,7 +25,8 @@ ScrollStateData::ScrollStateData() delta_granularity(ui::ScrollGranularity::kScrollByPrecisePixel), caused_scroll_x(false), caused_scroll_y(false), - is_scroll_chain_cut(false) {} + is_scroll_chain_cut(false), + is_main_thread_hit_tested(false) {} ScrollStateData::ScrollStateData(const ScrollStateData& other) = default; diff --git a/chromium/cc/input/scroll_state_data.h b/chromium/cc/input/scroll_state_data.h index 297517031ae..a3a2755c61b 100644 --- a/chromium/cc/input/scroll_state_data.h +++ b/chromium/cc/input/scroll_state_data.h @@ -70,12 +70,18 @@ class CC_EXPORT ScrollStateData { ElementId current_native_scrolling_element() const; void set_current_native_scrolling_element(ElementId element_id); + // Used in scroll unification to specify that a scroll state has been hit + // tested on the main thread. If this is true, the hit test result will be + // placed in the current_native_scrolling_element_. + bool is_main_thread_hit_tested; + private: // The id of the last native element to respond to a scroll, or 0 if none // exists. // TODO(bokan): In the compositor, this is now only used as an override to - // scroller targeting, i.e. we'll latch scrolling to the specified - // element_id. It will be renamed when the main thread is also converted. + // scroller targeting. I.e. we'll latch scrolling to the specified + // element_id. It will be renamed to a better name (target_element_id?) when + // the main thread is also converted. ElementId current_native_scrolling_element_; }; diff --git a/chromium/cc/input/scroll_utils.cc b/chromium/cc/input/scroll_utils.cc new file mode 100644 index 00000000000..e9c036e3896 --- /dev/null +++ b/chromium/cc/input/scroll_utils.cc @@ -0,0 +1,45 @@ +// Copyright 2020 The Chromium 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 "cc/input/scroll_utils.h" + +#include "base/numerics/ranges.h" +#include "ui/gfx/geometry/size_f.h" +#include "ui/gfx/geometry/vector2d_f.h" + +namespace cc { + +// static +gfx::Vector2dF ScrollUtils::ResolveScrollPercentageToPixels( + const gfx::Vector2dF& delta, + const gfx::SizeF& scroller, + const gfx::SizeF& viewport) { + // Work with unsigned values and keep sign information in sign_x / sign_y. + float sign_x = std::signbit(delta.x()) ? -1 : 1; + float sign_y = std::signbit(delta.y()) ? -1 : 1; + float delta_x = std::abs(delta.x()); + float delta_y = std::abs(delta.y()); + + // Resolved deltas in percent based scrolling are clamped at min by 16 pixels. + float min = kMinPixelDeltaForPercentBasedScroll; + + // Resolve and clamp horizontal scroll + if (delta_x > 0) { + delta_x = delta_x * std::min(scroller.width(), viewport.width()); + if (delta_x < min) + delta_x = min; + } + + // Resolve and clamps vertical scroll. + if (delta_y > 0) { + delta_y = delta_y * std::min(scroller.height(), viewport.height()); + if (delta_y < min) + delta_y = min; + } + + return gfx::Vector2dF(std::copysign(delta_x, sign_x), + std::copysign(delta_y, sign_y)); +} + +} // namespace cc diff --git a/chromium/cc/input/scroll_utils.h b/chromium/cc/input/scroll_utils.h new file mode 100644 index 00000000000..34fb3be7773 --- /dev/null +++ b/chromium/cc/input/scroll_utils.h @@ -0,0 +1,43 @@ +// Copyright 2020 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CC_INPUT_SCROLL_UTILS_H_ +#define CC_INPUT_SCROLL_UTILS_H_ + +#include "cc/cc_export.h" + +namespace gfx { +class Vector2dF; +class SizeF; +} // namespace gfx + +namespace cc { + +static constexpr int kPixelsPerLineStep = 40; +static constexpr float kMinFractionToStepWhenPaging = 0.875f; + +// Each directional scroll for percentage-based units should scroll 1/8th of +// the scrollable area. +static constexpr float kPercentDeltaForDirectionalScroll = 0.125f; + +// Scroll deltas are lower-bounded by 16 physical pixels in percent-based +// scrolls. +static constexpr float kMinPixelDeltaForPercentBasedScroll = 16; + +// Class for scroll helper methods in cc and blink. +class CC_EXPORT ScrollUtils { + public: + // Transforms a |scroll_delta| in percent units to pixel units based in its + // |scroller_size|. Clamps it by 16 pixels to avoid too small deltas for tiny + // scrollers and 12.5% of |viewport_size| to avoid too large deltas. + // Inputs and output muest be in physical pixels. + static gfx::Vector2dF ResolveScrollPercentageToPixels( + const gfx::Vector2dF& scroll_delta, + const gfx::SizeF& scroller_size, + const gfx::SizeF& viewport_size); +}; + +} // namespace cc + +#endif // CC_INPUT_SCROLL_UTILS_H_ diff --git a/chromium/cc/input/scrollbar.h b/chromium/cc/input/scrollbar.h index af8cef429b1..4fc7a3e57e9 100644 --- a/chromium/cc/input/scrollbar.h +++ b/chromium/cc/input/scrollbar.h @@ -11,13 +11,6 @@ #include "ui/gfx/geometry/point.h" #include "ui/gfx/geometry/rect.h" -static constexpr int kPixelsPerLineStep = 40; -static constexpr float kMinFractionToStepWhenPaging = 0.875f; - -// Each directional scroll for percentage-based units should scroll 1/8th of -// the scrollable area. -static constexpr float kPercentDeltaForDirectionalScroll = 0.125f; - // Autoscrolling (on the main thread) happens by applying a delta every 50ms. // Hence, pixels per second for a autoscroll cc animation can be calculated as: // autoscroll velocity = delta / 0.05 sec = delta x 20 @@ -58,6 +51,7 @@ class Scrollbar : public base::RefCounted<Scrollbar> { virtual bool IsOverlay() const = 0; virtual bool HasThumb() const = 0; virtual bool SupportsDragSnapBack() const = 0; + virtual bool JumpOnTrackClick() const = 0; // The following rects are all relative to the scrollbar's origin. // The location of ThumbRect reflects scroll offset, but cc will ignore it diff --git a/chromium/cc/input/scrollbar_animation_controller.cc b/chromium/cc/input/scrollbar_animation_controller.cc index 2435aa156fe..50242fb337c 100644 --- a/chromium/cc/input/scrollbar_animation_controller.cc +++ b/chromium/cc/input/scrollbar_animation_controller.cc @@ -51,8 +51,6 @@ ScrollbarAnimationController::ScrollbarAnimationController( is_animating_(false), animation_change_(NONE), scroll_element_id_(scroll_element_id), - currently_scrolling_(false), - show_in_fast_scroll_(false), opacity_(initial_opacity), show_scrollbars_on_scroll_gesture_(false), need_thinning_animation_(false), @@ -73,8 +71,6 @@ ScrollbarAnimationController::ScrollbarAnimationController( is_animating_(false), animation_change_(NONE), scroll_element_id_(scroll_element_id), - currently_scrolling_(false), - show_in_fast_scroll_(false), opacity_(initial_opacity), show_scrollbars_on_scroll_gesture_(true), need_thinning_animation_(true), @@ -182,25 +178,6 @@ void ScrollbarAnimationController::RunAnimationFrame(float progress) { StopAnimation(); } -void ScrollbarAnimationController::DidScrollBegin() { - currently_scrolling_ = true; -} - -void ScrollbarAnimationController::DidScrollEnd() { - bool has_scrolled = show_in_fast_scroll_; - show_in_fast_scroll_ = false; - - currently_scrolling_ = false; - - // We don't fade out scrollbar if they need thinning animation and mouse is - // near. - if (need_thinning_animation_ && MouseIsNearAnyScrollbar()) - return; - - if (has_scrolled && !tickmarks_showing_) - PostDelayedAnimation(FADE_OUT); -} - void ScrollbarAnimationController::DidScrollUpdate() { UpdateScrollbarState(); } @@ -213,19 +190,13 @@ void ScrollbarAnimationController::UpdateScrollbarState() { Show(); - // As an optimization, we avoid spamming fade delay tasks during active fast - // scrolls. But if we're not within one, we need to post every scroll update. - if (!currently_scrolling_) { - // We don't fade out scrollbar if they need thinning animation (Aura - // Overlay) and mouse is near or tickmarks show. - if (need_thinning_animation_) { - if (!MouseIsNearAnyScrollbar() && !tickmarks_showing_) - PostDelayedAnimation(FADE_OUT); - } else { + // We don't fade out scrollbar if they need thinning animation (Aura + // Overlay) and mouse is near or tickmarks show. + if (need_thinning_animation_) { + if (!MouseIsNearAnyScrollbar() && !tickmarks_showing_) PostDelayedAnimation(FADE_OUT); - } } else { - show_in_fast_scroll_ = true; + PostDelayedAnimation(FADE_OUT); } if (need_thinning_animation_) { diff --git a/chromium/cc/input/scrollbar_animation_controller.h b/chromium/cc/input/scrollbar_animation_controller.h index 67a9ed5c8fc..1f2c22af131 100644 --- a/chromium/cc/input/scrollbar_animation_controller.h +++ b/chromium/cc/input/scrollbar_animation_controller.h @@ -72,9 +72,6 @@ class CC_EXPORT ScrollbarAnimationController { // Effect both Android and Aura Overlay Scrollbar. void DidScrollUpdate(); - void DidScrollBegin(); - void DidScrollEnd(); - void DidMouseDown(); void DidMouseUp(); void DidMouseLeave(); @@ -150,8 +147,6 @@ class CC_EXPORT ScrollbarAnimationController { AnimationChange animation_change_; const ElementId scroll_element_id_; - bool currently_scrolling_; - bool show_in_fast_scroll_; base::CancelableOnceClosure delayed_scrollbar_animation_; diff --git a/chromium/cc/input/scrollbar_animation_controller_unittest.cc b/chromium/cc/input/scrollbar_animation_controller_unittest.cc index f9593321d61..985f45bae4b 100644 --- a/chromium/cc/input/scrollbar_animation_controller_unittest.cc +++ b/chromium/cc/input/scrollbar_animation_controller_unittest.cc @@ -163,9 +163,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, AppearOnResize) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); ExpectScrollbarsOpacity(1); // Make the Layer non-scrollable, scrollbar disappears. @@ -199,13 +197,9 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, HideOnResize) { scroll_layer_->UpdateScrollable(); UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(1, h_scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollEnd(); - // Shrink along Y axis and expand along X, horizontal scrollbar // should disappear. clip_layer_->SetBounds(gfx::Size(200, 100)); @@ -214,12 +208,8 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, HideOnResize) { scroll_layer_->UpdateScrollable(); UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(0.0f, h_scrollbar_layer_->Opacity()); - - scrollbar_controller_->DidScrollEnd(); } // Scroll content. Confirm the scrollbar appears and fades out. @@ -232,7 +222,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicAppearAndFadeOut) { EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden()); // Scrollbar should appear only on scroll update. - scrollbar_controller_->DidScrollBegin(); ExpectScrollbarsOpacity(0); EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden()); @@ -240,7 +229,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicAppearAndFadeOut) { ExpectScrollbarsOpacity(1); EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden()); - scrollbar_controller_->DidScrollEnd(); ExpectScrollbarsOpacity(1); EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden()); @@ -295,9 +283,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -355,9 +341,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MoveNearAndDontFadeOut) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -396,9 +380,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MoveOverAndDontFadeOut) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -438,9 +420,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -466,9 +446,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -502,9 +480,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, DontFadeWhileCaptured) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -540,9 +516,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, FadeAfterReleasedFar) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -591,9 +565,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, DontFadeAfterReleasedNear) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // An fade out animation should have been enqueued. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -630,9 +602,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // A fade out animation should have been enqueued. Start it. EXPECT_EQ(kFadeDelay, client_.delay()); @@ -670,9 +640,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, TestCantCaptureWhenFaded) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); EXPECT_EQ(kFadeDelay, client_.delay()); EXPECT_FALSE(client_.start_fade().is_null()); @@ -748,7 +716,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ScrollWithMouseNear) { EXPECT_FLOAT_EQ(kIdleThicknessScale, h_scrollbar_layer_->thumb_thickness_scale_factor()); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); // Now that we've received a scroll, we should be thick without an animation. @@ -756,7 +723,6 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ScrollWithMouseNear) { // An animation for the fade should be either null or cancelled, since // mouse is still near the scrollbar. - scrollbar_controller_->DidScrollEnd(); EXPECT_TRUE(client_.start_fade().is_null() || client_.start_fade().IsCancelled()); @@ -775,29 +741,16 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ScrollWithMouseNear) { h_scrollbar_layer_->thumb_thickness_scale_factor()); } -// Tests that main thread scroll updates immediatley queue a fade out animation -// without requiring a ScrollEnd. +// Tests that main thread scroll updates immediately queue a fade out animation TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MainThreadScrollQueuesFade) { ASSERT_TRUE(client_.start_fade().is_null()); - // A ScrollUpdate without a ScrollBegin indicates a main thread scroll update - // so we should schedule a fade out animation without waiting for a ScrollEnd - // (which will never come). + // A ScrollUpdate indicates a main thread scroll update so we should schedule + // a fade out animation since there is no scroll end notification. scrollbar_controller_->DidScrollUpdate(); EXPECT_FALSE(client_.start_fade().is_null()); EXPECT_EQ(kFadeDelay, client_.delay()); - - client_.start_fade().Reset(); - - // If we got a ScrollBegin, we shouldn't schedule the fade out animation until - // we get a corresponding ScrollEnd. - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); - EXPECT_TRUE(client_.start_fade().is_null()); - scrollbar_controller_->DidScrollEnd(); - EXPECT_FALSE(client_.start_fade().is_null()); - EXPECT_EQ(kFadeDelay, client_.delay()); } // Tests that the fade effect is animated. @@ -806,9 +759,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, FadeAnimated) { time += base::TimeDelta::FromSeconds(1); // Scroll to make the scrollbars visible. - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // Appearance is instant. ExpectScrollbarsOpacity(1); @@ -838,13 +789,10 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, NotifyChangedVisibility) { EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(1); // Scroll to make the scrollbars visible. - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden()); Mock::VerifyAndClearExpectations(&client_); - scrollbar_controller_->DidScrollEnd(); - // Play out the fade out animation. We shouldn't notify that the scrollbars // are hidden until the animation is completly over. We can (but don't have // to) notify during the animation that the scrollbars are still visible. @@ -886,9 +834,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseNearEach) { time += base::TimeDelta::FromSeconds(1); // Scroll to make the scrollbars visible. - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // Near vertical scrollbar. scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0)); @@ -979,9 +925,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseNearBoth) { time += base::TimeDelta::FromSeconds(1); // Scroll to make the scrollbars visible. - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // Move scrollbar thumb to the end of track. v_scrollbar_layer_->SetCurrentPos(100); @@ -1012,9 +956,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, time += base::TimeDelta::FromSeconds(1); // Scroll to make the scrollbars visible. - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // Near vertical scrollbar. scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0)); @@ -1076,9 +1018,7 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseLeaveFadeOut) { scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0)); // Scroll to make the scrollbars visible. - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); // Should not have delay fadeout animation. EXPECT_TRUE(client_.start_fade().is_null() || @@ -1323,11 +1263,9 @@ TEST_F(ScrollbarAnimationControllerAuraOverlayTest, TickmakrsShowHide) { client_.start_fade().IsCancelled()); // Scroll update with phase, no delay fade animation. - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); EXPECT_TRUE(client_.start_fade().is_null() || client_.start_fade().IsCancelled()); - scrollbar_controller_->DidScrollEnd(); EXPECT_TRUE(client_.start_fade().is_null() || client_.start_fade().IsCancelled()); @@ -1430,13 +1368,11 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HiddenInBegin) { TEST_F(ScrollbarAnimationControllerAndroidTest, HiddenAfterNonScrollingGesture) { scrollbar_layer_->SetOverlayScrollbarLayerOpacityAnimated(0.f); - scrollbar_controller_->DidScrollBegin(); base::TimeTicks time; time += base::TimeDelta::FromSeconds(100); scrollbar_controller_->Animate(time); EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollEnd(); EXPECT_TRUE(start_fade_.is_null()); @@ -1473,11 +1409,9 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnResize) { GetScrollNode(scroll_layer_)->container_bounds = gfx::Size(100, 200); scroll_layer_->UpdateScrollable(); UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollEnd(); // Shrink along Y axis and expand along X, horizontal scrollbar // should disappear. @@ -1485,12 +1419,8 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnResize) { scroll_layer_->UpdateScrollable(); UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity()); - - scrollbar_controller_->DidScrollEnd(); } TEST_F(VerticalScrollbarAnimationControllerAndroidTest, HideOnResize) { @@ -1502,23 +1432,17 @@ TEST_F(VerticalScrollbarAnimationControllerAndroidTest, HideOnResize) { GetScrollNode(scroll_layer_)->container_bounds = gfx::Size(100, 200); scroll_layer_->UpdateScrollable(); UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollEnd(); // Shrink along Y axis and expand along X, vertical scrollbar should appear. GetScrollNode(scroll_layer_)->container_bounds = gfx::Size(200, 100); scroll_layer_->UpdateScrollable(); UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity()); - - scrollbar_controller_->DidScrollEnd(); } TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnUserNonScrollableHorz) { @@ -1527,12 +1451,8 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, HideOnUserNonScrollableHorz) { GetScrollNode(scroll_layer_)->user_scrollable_horizontal = false; UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity()); - - scrollbar_controller_->DidScrollEnd(); } TEST_F(ScrollbarAnimationControllerAndroidTest, ShowOnUserNonScrollableVert) { @@ -1541,12 +1461,8 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, ShowOnUserNonScrollableVert) { GetScrollNode(scroll_layer_)->user_scrollable_vertical = false; UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity()); - - scrollbar_controller_->DidScrollEnd(); } TEST_F(VerticalScrollbarAnimationControllerAndroidTest, @@ -1556,12 +1472,8 @@ TEST_F(VerticalScrollbarAnimationControllerAndroidTest, GetScrollNode(scroll_layer_)->user_scrollable_vertical = false; UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity()); - - scrollbar_controller_->DidScrollEnd(); } TEST_F(VerticalScrollbarAnimationControllerAndroidTest, @@ -1571,32 +1483,26 @@ TEST_F(VerticalScrollbarAnimationControllerAndroidTest, GetScrollNode(scroll_layer_)->user_scrollable_horizontal = false; UpdateActiveTreeDrawProperties(); - scrollbar_controller_->DidScrollBegin(); - scrollbar_controller_->DidScrollUpdate(); EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity()); - - scrollbar_controller_->DidScrollEnd(); } TEST_F(ScrollbarAnimationControllerAndroidTest, AwakenByScrollingGesture) { base::TimeTicks time; time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); EXPECT_FALSE(did_request_animate_); scrollbar_controller_->DidScrollUpdate(); EXPECT_FALSE(did_request_animate_); EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity()); - EXPECT_TRUE(start_fade_.is_null()); + EXPECT_FALSE(start_fade_.is_null()); time += base::TimeDelta::FromSeconds(100); scrollbar_controller_->Animate(time); EXPECT_FALSE(did_request_animate_); EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollEnd(); EXPECT_FALSE(did_request_animate_); std::move(start_fade_).Run(); EXPECT_TRUE(did_request_animate_); @@ -1622,9 +1528,7 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, AwakenByScrollingGesture) { time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollBegin(); scrollbar_controller_->DidScrollUpdate(); - scrollbar_controller_->DidScrollEnd(); std::move(start_fade_).Run(); EXPECT_TRUE(did_request_animate_); @@ -1743,7 +1647,6 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, did_request_animate_ = false; EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollBegin(); EXPECT_FALSE(did_request_animate_); EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity()); @@ -1753,7 +1656,6 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, did_request_animate_ = false; EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollEnd(); EXPECT_FALSE(did_request_animate_); EXPECT_FLOAT_EQ(1.0f / 3.0f, scrollbar_layer_->Opacity()); @@ -1783,7 +1685,6 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, did_request_animate_ = false; EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity()); - scrollbar_controller_->DidScrollBegin(); EXPECT_FLOAT_EQ(2.0f / 3.0f, scrollbar_layer_->Opacity()); time += base::TimeDelta::FromSeconds(1); @@ -1798,10 +1699,10 @@ TEST_F(ScrollbarAnimationControllerAndroidTest, EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity()); time += base::TimeDelta::FromSeconds(1); - scrollbar_controller_->DidScrollEnd(); EXPECT_FALSE(did_request_animate_); EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity()); } } // namespace + } // namespace cc diff --git a/chromium/cc/input/scrollbar_controller.cc b/chromium/cc/input/scrollbar_controller.cc index aac1d4ceccd..490cd44d1d4 100644 --- a/chromium/cc/input/scrollbar_controller.cc +++ b/chromium/cc/input/scrollbar_controller.cc @@ -8,6 +8,7 @@ #include "base/cancelable_callback.h" #include "cc/base/math_util.h" +#include "cc/input/scroll_utils.h" #include "cc/input/scrollbar.h" #include "cc/input/scrollbar_controller.h" #include "cc/trees/layer_tree_impl.h" @@ -35,7 +36,7 @@ void ScrollbarController::WillBeginImplFrame() { } // Retrieves the ScrollbarLayerImplBase corresponding to the stashed ElementId. -ScrollbarLayerImplBase* ScrollbarController::ScrollbarLayer() { +ScrollbarLayerImplBase* ScrollbarController::ScrollbarLayer() const { if (!captured_scrollbar_metadata_.has_value()) return nullptr; @@ -52,7 +53,7 @@ ScrollbarLayerImplBase* ScrollbarController::ScrollbarLayer() { // GSU. InputHandlerPointerResult ScrollbarController::HandlePointerDown( const gfx::PointF position_in_widget, - bool shift_modifier) { + bool jump_key_modifier) { LayerImpl* layer_impl = GetLayerHitByPoint(position_in_widget); // If a non-custom scrollbar layer was not found, we return early as there is @@ -88,12 +89,15 @@ InputHandlerPointerResult ScrollbarController::HandlePointerDown( scroll_result.type = PointerResultType::kScrollbarScroll; layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries(); const ScrollbarPart scrollbar_part = - GetScrollbarPartFromPointerDown(scrollbar, position_in_widget); + GetScrollbarPartFromPointerDown(position_in_widget); + const bool perform_jump_click_on_track = + scrollbar->JumpOnTrackClick() != jump_key_modifier; scroll_result.scroll_offset = GetScrollOffsetForScrollbarPart( - scrollbar, scrollbar_part, shift_modifier); + scrollbar_part, perform_jump_click_on_track); last_known_pointer_position_ = position_in_widget; scrollbar_scroll_is_active_ = true; - scroll_result.scroll_units = Granularity(scrollbar_part, shift_modifier); + scroll_result.scroll_units = + Granularity(scrollbar_part, perform_jump_click_on_track); if (scrollbar_part == ScrollbarPart::THUMB) { drag_state_ = DragState(); drag_state_->drag_origin = position_in_widget; @@ -112,12 +116,12 @@ InputHandlerPointerResult ScrollbarController::HandlePointerDown( // have the potential of initiating an autoscroll (if held down for long // enough). DCHECK(scrollbar_part != ScrollbarPart::THUMB); - cancelable_autoscroll_task_ = std::make_unique<base::CancelableOnceClosure>( - base::BindOnce(&ScrollbarController::StartAutoScrollAnimation, - base::Unretained(this), - InitialDeltaToAutoscrollVelocity( - scrollbar, scroll_result.scroll_offset), - scrollbar, scrollbar_part)); + cancelable_autoscroll_task_ = + std::make_unique<base::CancelableOnceClosure>(base::BindOnce( + &ScrollbarController::StartAutoScrollAnimation, + base::Unretained(this), + InitialDeltaToAutoscrollVelocity(scroll_result.scroll_offset), + scrollbar_part)); layer_tree_host_impl_->task_runner_provider() ->ImplThreadTaskRunner() ->PostDelayedTask(FROM_HERE, cancelable_autoscroll_task_->callback(), @@ -127,16 +131,16 @@ InputHandlerPointerResult ScrollbarController::HandlePointerDown( } bool ScrollbarController::SnapToDragOrigin( - const ScrollbarLayerImplBase* scrollbar, - const gfx::PointF pointer_position_in_widget) { + const gfx::PointF pointer_position_in_widget) const { // Consult the ScrollbarTheme to check if thumb snapping is supported on the // current platform. + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); if (!(scrollbar && scrollbar->SupportsDragSnapBack())) return false; bool clipped = false; - const gfx::PointF pointer_position_in_layer = GetScrollbarRelativePosition( - scrollbar, pointer_position_in_widget, &clipped); + const gfx::PointF pointer_position_in_layer = + GetScrollbarRelativePosition(pointer_position_in_widget, &clipped); if (clipped) return false; @@ -189,10 +193,10 @@ bool ScrollbarController::SnapToDragOrigin( ui::ScrollGranularity ScrollbarController::Granularity( const ScrollbarPart scrollbar_part, - const bool shift_modifier) { + const bool jump_key_modifier) const { const bool shift_click_on_scrollbar_track = - shift_modifier && (scrollbar_part == ScrollbarPart::FORWARD_TRACK || - scrollbar_part == ScrollbarPart::BACK_TRACK); + jump_key_modifier && (scrollbar_part == ScrollbarPart::FORWARD_TRACK || + scrollbar_part == ScrollbarPart::BACK_TRACK); if (shift_click_on_scrollbar_track || scrollbar_part == ScrollbarPart::THUMB) return ui::ScrollGranularity::kScrollByPrecisePixel; @@ -201,17 +205,17 @@ ui::ScrollGranularity ScrollbarController::Granularity( return ui::ScrollGranularity::kScrollByPixel; } -float ScrollbarController::GetScrollDeltaForAbsoluteJump( - const ScrollbarLayerImplBase* scrollbar) { +float ScrollbarController::GetScrollDeltaForAbsoluteJump() const { layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries(); bool clipped = false; - const gfx::PointF pointer_position_in_layer = GetScrollbarRelativePosition( - scrollbar, last_known_pointer_position_, &clipped); + const gfx::PointF pointer_position_in_layer = + GetScrollbarRelativePosition(last_known_pointer_position_, &clipped); if (clipped) return 0; + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); const float pointer_location = scrollbar->orientation() == ScrollbarOrientation::VERTICAL ? pointer_position_in_layer.y() @@ -232,19 +236,18 @@ float ScrollbarController::GetScrollDeltaForAbsoluteJump( const float delta = round(std::abs(desired_thumb_origin - current_thumb_origin)); - return delta * GetScrollerToScrollbarRatio(scrollbar); + return delta * GetScrollerToScrollbarRatio(); } int ScrollbarController::GetScrollDeltaForDragPosition( - const ScrollbarLayerImplBase* scrollbar, - const gfx::PointF pointer_position_in_widget) { + const gfx::PointF pointer_position_in_widget) const { + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); const float pointer_delta = scrollbar->orientation() == ScrollbarOrientation::VERTICAL ? pointer_position_in_widget.y() - drag_state_->drag_origin.y() : pointer_position_in_widget.x() - drag_state_->drag_origin.x(); - const float new_offset = - pointer_delta * GetScrollerToScrollbarRatio(scrollbar); + const float new_offset = pointer_delta * GetScrollerToScrollbarRatio(); const float scroll_delta = drag_state_->scroll_position_at_start_ + new_offset - scrollbar->current_pos(); @@ -276,7 +279,7 @@ InputHandlerPointerResult ScrollbarController::HandlePointerMove( if (drag_processed_for_current_frame_) return scroll_result; - if (SnapToDragOrigin(scrollbar, position_in_widget)) { + if (SnapToDragOrigin(position_in_widget)) { const float delta = scrollbar->current_pos() - drag_state_->scroll_position_at_start_; scroll_result.scroll_units = ui::ScrollGranularity::kScrollByPrecisePixel; @@ -302,7 +305,7 @@ InputHandlerPointerResult ScrollbarController::HandlePointerMove( // valid ScrollNode. DCHECK(target_node); - int delta = GetScrollDeltaForDragPosition(scrollbar, position_in_widget); + int delta = GetScrollDeltaForDragPosition(position_in_widget); if (drag_state_->scroller_length_at_previous_move != scrollbar->scroll_layer_length()) { drag_state_->scroller_displacement = delta; @@ -339,8 +342,7 @@ InputHandlerPointerResult ScrollbarController::HandlePointerMove( return scroll_result; } -float ScrollbarController::GetScrollerToScrollbarRatio( - const ScrollbarLayerImplBase* scrollbar) { +float ScrollbarController::GetScrollerToScrollbarRatio() const { // Calculating the delta by which the scroller layer should move when // dragging the thumb depends on the following factors: // - scrollbar_track_length @@ -381,6 +383,7 @@ float ScrollbarController::GetScrollerToScrollbarRatio( // |<- scrollbar_thumb_length ->| // layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries(); + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); float scroll_layer_length = scrollbar->scroll_layer_length(); float scrollbar_track_length = scrollbar->TrackLength(); gfx::Rect thumb_rect(scrollbar->ComputeThumbQuadRect()); @@ -388,7 +391,7 @@ float ScrollbarController::GetScrollerToScrollbarRatio( scrollbar->orientation() == ScrollbarOrientation::VERTICAL ? thumb_rect.height() : thumb_rect.width(); - int viewport_length = GetViewportLength(scrollbar); + int viewport_length = GetViewportLength(); return (scroll_layer_length - viewport_length) / (scrollbar_track_length - scrollbar_thumb_length); @@ -399,11 +402,18 @@ void ScrollbarController::ResetState() { drag_state_ = base::nullopt; autoscroll_state_ = base::nullopt; captured_scrollbar_metadata_ = base::nullopt; + if (cancelable_autoscroll_task_) { + cancelable_autoscroll_task_->Cancel(); + cancelable_autoscroll_task_.reset(); + } } -void ScrollbarController::DidUnregisterScrollbar(ElementId element_id) { +void ScrollbarController::DidUnregisterScrollbar( + ElementId element_id, + ScrollbarOrientation orientation) { if (captured_scrollbar_metadata_.has_value() && - captured_scrollbar_metadata_->scroll_element_id == element_id) + captured_scrollbar_metadata_->scroll_element_id == element_id && + captured_scrollbar_metadata_->orientation == orientation) ResetState(); } @@ -413,12 +423,10 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() { return; layer_tree_host_impl_->active_tree()->UpdateScrollbarGeometries(); - const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); - const gfx::Rect thumb_quad = scrollbar->ComputeThumbQuadRect(); bool clipped; - gfx::PointF scroller_relative_position(GetScrollbarRelativePosition( - scrollbar, last_known_pointer_position_, &clipped)); + gfx::PointF scroller_relative_position( + GetScrollbarRelativePosition(last_known_pointer_position_, &clipped)); if (clipped) return; @@ -429,6 +437,8 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() { int thumb_start = 0; int thumb_end = 0; int pointer_position = 0; + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); + const gfx::Rect thumb_quad = scrollbar->ComputeThumbQuadRect(); if (scrollbar->orientation() == ScrollbarOrientation::VERTICAL) { thumb_start = thumb_quad.y(); thumb_end = thumb_quad.y() + thumb_quad.height(); @@ -458,7 +468,7 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() { const float scroll_layer_length = scrollbar->scroll_layer_length(); if (autoscroll_state_->scroll_layer_length != scroll_layer_length) { layer_tree_host_impl_->mutator_host()->ScrollAnimationAbort(); - StartAutoScrollAnimation(autoscroll_state_->velocity, scrollbar, + StartAutoScrollAnimation(autoscroll_state_->velocity, autoscroll_state_->pressed_scrollbar_part); } } @@ -466,8 +476,8 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() { // The animations need to be aborted/restarted based on the pointer location // (i.e leaving/entering the track/arrows, reaching the track end etc). The // autoscroll_state_ however, needs to be reset on pointer changes. - const gfx::RectF scrollbar_part_rect(GetRectForScrollbarPart( - scrollbar, autoscroll_state_->pressed_scrollbar_part)); + const gfx::RectF scrollbar_part_rect( + GetRectForScrollbarPart(autoscroll_state_->pressed_scrollbar_part)); if (!scrollbar_part_rect.Contains(scroller_relative_position)) { // Stop animating if pointer moves outside the rect bounds. layer_tree_host_impl_->mutator_host()->ScrollAnimationAbort(); @@ -475,17 +485,17 @@ void ScrollbarController::RecomputeAutoscrollStateIfNeeded() { !layer_tree_host_impl_->mutator_host()->IsElementAnimating( scrollbar->scroll_element_id())) { // Start animating if pointer re-enters the bounds. - StartAutoScrollAnimation(autoscroll_state_->velocity, scrollbar, + StartAutoScrollAnimation(autoscroll_state_->velocity, autoscroll_state_->pressed_scrollbar_part); } } // Helper to calculate the autoscroll velocity. float ScrollbarController::InitialDeltaToAutoscrollVelocity( - const ScrollbarLayerImplBase* scrollbar, gfx::ScrollOffset scroll_offset) const { + DCHECK(captured_scrollbar_metadata_.has_value()); const float scroll_delta = - scrollbar->orientation() == ScrollbarOrientation::VERTICAL + ScrollbarLayer()->orientation() == ScrollbarOrientation::VERTICAL ? scroll_offset.y() : scroll_offset.x(); return scroll_delta * kAutoscrollMultiplier; @@ -493,15 +503,17 @@ float ScrollbarController::InitialDeltaToAutoscrollVelocity( void ScrollbarController::StartAutoScrollAnimation( const float velocity, - const ScrollbarLayerImplBase* scrollbar, ScrollbarPart pressed_scrollbar_part) { // Autoscroll and thumb drag are mutually exclusive. Both can't be active at // the same time. DCHECK(!drag_state_.has_value()); + DCHECK(captured_scrollbar_metadata_.has_value()); DCHECK_NE(velocity, 0); + DCHECK(ScrollbarLayer()); // scroll_node is set up while handling GSB. If there's no node to scroll, we // don't need to create any animation for it. + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); ScrollTree& scroll_tree = layer_tree_host_impl_->active_tree()->property_trees()->scroll_tree; ScrollNode* scroll_node = @@ -552,18 +564,13 @@ InputHandlerPointerResult ScrollbarController::HandlePointerUp( if (autoscroll_state_.has_value()) layer_tree_host_impl_->mutator_host()->ScrollAnimationAbort(); - if (cancelable_autoscroll_task_) { - cancelable_autoscroll_task_->Cancel(); - cancelable_autoscroll_task_.reset(); - } - ResetState(); return scroll_result; } // Returns the layer that is hit by the position_in_widget. LayerImpl* ScrollbarController::GetLayerHitByPoint( - const gfx::PointF position_in_widget) { + const gfx::PointF position_in_widget) const { LayerTreeImpl* active_tree = layer_tree_host_impl_->active_tree(); gfx::Point viewport_point(position_in_widget.x(), position_in_widget.y()); @@ -575,8 +582,8 @@ LayerImpl* ScrollbarController::GetLayerHitByPoint( return layer_impl; } -int ScrollbarController::GetViewportLength( - const ScrollbarLayerImplBase* scrollbar) const { +int ScrollbarController::GetViewportLength() const { + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); const ScrollNode* scroll_node = layer_tree_host_impl_->active_tree() ->property_trees() @@ -587,30 +594,51 @@ int ScrollbarController::GetViewportLength( : scroll_node->container_bounds.width(); } +int ScrollbarController::GetScrollDeltaForPercentBasedScroll() const { + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); + + const ScrollNode* scroll_node = + layer_tree_host_impl_->active_tree() + ->property_trees() + ->scroll_tree.FindNodeFromElementId(scrollbar->scroll_element_id()); + DCHECK(scroll_node); + + const gfx::Vector2dF scroll_delta = + scrollbar->orientation() == ScrollbarOrientation::VERTICAL + ? gfx::Vector2dF(0, kPercentDeltaForDirectionalScroll) + : gfx::Vector2dF(kPercentDeltaForDirectionalScroll, 0); + + const gfx::Vector2dF pixel_delta = + layer_tree_host_impl_->ResolveScrollGranularityToPixels( + *scroll_node, scroll_delta, + ui::ScrollGranularity::kScrollByPercentage); + + return scrollbar->orientation() == ScrollbarOrientation::VERTICAL + ? pixel_delta.y() + : pixel_delta.x(); +} + int ScrollbarController::GetScrollDeltaForScrollbarPart( - const ScrollbarLayerImplBase* scrollbar, const ScrollbarPart scrollbar_part, - const bool shift_modifier) { + const bool jump_key_modifier) const { int scroll_delta = 0; switch (scrollbar_part) { case ScrollbarPart::BACK_BUTTON: case ScrollbarPart::FORWARD_BUTTON: if (layer_tree_host_impl_->settings().percent_based_scrolling) { - scroll_delta = - kPercentDeltaForDirectionalScroll * GetViewportLength(scrollbar); + scroll_delta = GetScrollDeltaForPercentBasedScroll(); } else { scroll_delta = kPixelsPerLineStep * ScreenSpaceScaleFactor(); } break; case ScrollbarPart::BACK_TRACK: case ScrollbarPart::FORWARD_TRACK: { - if (shift_modifier) { - scroll_delta = GetScrollDeltaForAbsoluteJump(scrollbar); + if (jump_key_modifier) { + scroll_delta = GetScrollDeltaForAbsoluteJump(); break; } - scroll_delta = - GetViewportLength(scrollbar) * kMinFractionToStepWhenPaging; + scroll_delta = GetViewportLength() * kMinFractionToStepWhenPaging; break; } default: @@ -634,9 +662,8 @@ float ScrollbarController::ScreenSpaceScaleFactor() const { } gfx::PointF ScrollbarController::GetScrollbarRelativePosition( - const ScrollbarLayerImplBase* scrollbar, const gfx::PointF position_in_widget, - bool* clipped) { + bool* clipped) const { gfx::Transform inverse_screen_space_transform( gfx::Transform::kSkipInitialization); @@ -647,7 +674,7 @@ gfx::PointF ScrollbarController::GetScrollbarRelativePosition( ? 1.f / layer_tree_host_impl_->active_tree()->device_scale_factor() : 1.f; gfx::Transform scaled_screen_space_transform( - scrollbar->ScreenSpaceTransform()); + ScrollbarLayer()->ScreenSpaceTransform()); scaled_screen_space_transform.PostScale(scale, scale); if (!scaled_screen_space_transform.GetInverse( &inverse_screen_space_transform)) @@ -659,14 +686,14 @@ gfx::PointF ScrollbarController::GetScrollbarRelativePosition( // Determines the ScrollbarPart based on the position_in_widget. ScrollbarPart ScrollbarController::GetScrollbarPartFromPointerDown( - const ScrollbarLayerImplBase* scrollbar, - const gfx::PointF position_in_widget) { + const gfx::PointF position_in_widget) const { // position_in_widget needs to be transformed and made relative to the // scrollbar layer because hit testing assumes layer relative coordinates. + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); bool clipped = false; const gfx::PointF scroller_relative_position( - GetScrollbarRelativePosition(scrollbar, position_in_widget, &clipped)); + GetScrollbarRelativePosition(position_in_widget, &clipped)); if (clipped) return ScrollbarPart::NO_PART; @@ -676,8 +703,8 @@ ScrollbarPart ScrollbarController::GetScrollbarPartFromPointerDown( // Determines the corresponding rect for the given scrollbar part. gfx::Rect ScrollbarController::GetRectForScrollbarPart( - const ScrollbarLayerImplBase* scrollbar, - const ScrollbarPart scrollbar_part) { + const ScrollbarPart scrollbar_part) const { + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); if (scrollbar_part == ScrollbarPart::BACK_BUTTON) return scrollbar->BackButtonRect(); if (scrollbar_part == ScrollbarPart::FORWARD_BUTTON) @@ -692,11 +719,11 @@ gfx::Rect ScrollbarController::GetRectForScrollbarPart( // Determines the scroll offsets based on the ScrollbarPart and the scrollbar // orientation. gfx::ScrollOffset ScrollbarController::GetScrollOffsetForScrollbarPart( - const ScrollbarLayerImplBase* scrollbar, const ScrollbarPart scrollbar_part, - const bool shift_modifier) { + const bool jump_key_modifier) const { + const ScrollbarLayerImplBase* scrollbar = ScrollbarLayer(); float scroll_delta = - GetScrollDeltaForScrollbarPart(scrollbar, scrollbar_part, shift_modifier); + GetScrollDeltaForScrollbarPart(scrollbar_part, jump_key_modifier); // See CreateScrollStateForGesture for more information on how these values // will be interpreted. diff --git a/chromium/cc/input/scrollbar_controller.h b/chromium/cc/input/scrollbar_controller.h index 4177c3464e5..ebe4dde9f09 100644 --- a/chromium/cc/input/scrollbar_controller.h +++ b/chromium/cc/input/scrollbar_controller.h @@ -119,24 +119,31 @@ class CC_EXPORT ScrollbarController { explicit ScrollbarController(LayerTreeHostImpl*); virtual ~ScrollbarController(); + // On Mac, the "jump to the spot that's clicked" setting can be dynamically + // set via System Preferences. When enabled, the expectation is that regular + // clicks on the scrollbar should make the scroller "jump" to the clicked + // location rather than animated scrolling. Additionally, when this is enabled + // and the user does an Option + click on the scrollbar, the scroller should + // *not* jump to that spot (i.e it should be treated as a regular track + // click). When this setting is disabled on the Mac, Option + click should + // make the scroller jump and a regular click should animate the scroll + // offset. On all other platforms, the "jump on click" option is available + // (via Shift + click) but is not configurable. InputHandlerPointerResult HandlePointerDown( const gfx::PointF position_in_widget, - const bool shift_modifier); + const bool jump_key_modifier); InputHandlerPointerResult HandlePointerMove( const gfx::PointF position_in_widget); InputHandlerPointerResult HandlePointerUp( const gfx::PointF position_in_widget); - // "velocity" here is calculated based on the initial scroll delta (See - // InitialDeltaToAutoscrollVelocity). This value carries a "sign" which is - // needed to determine whether we should set up the autoscrolling in the - // forwards or the backwards direction. - void StartAutoScrollAnimation(float velocity, - const ScrollbarLayerImplBase* scrollbar, - ScrollbarPart pressed_scrollbar_part); - bool ScrollbarScrollIsActive() { return scrollbar_scroll_is_active_; } - void DidUnregisterScrollbar(ElementId element_id); - ScrollbarLayerImplBase* ScrollbarLayer(); + bool AutoscrollTaskIsScheduled() const { + return cancelable_autoscroll_task_ != nullptr; + } + bool ScrollbarScrollIsActive() const { return scrollbar_scroll_is_active_; } + void DidUnregisterScrollbar(ElementId element_id, + ScrollbarOrientation orientation); + ScrollbarLayerImplBase* ScrollbarLayer() const; void WillBeginImplFrame(); void ResetState(); @@ -187,44 +194,42 @@ class CC_EXPORT ScrollbarController { ScrollbarOrientation orientation; }; + // "velocity" here is calculated based on the initial scroll delta (See + // InitialDeltaToAutoscrollVelocity). This value carries a "sign" which is + // needed to determine whether we should set up the autoscrolling in the + // forwards or the backwards direction. + void StartAutoScrollAnimation(float velocity, + ScrollbarPart pressed_scrollbar_part); + // Returns the DSF based on whether use-zoom-for-dsf is enabled. float ScreenSpaceScaleFactor() const; // Helper to convert scroll offset to autoscroll velocity. - float InitialDeltaToAutoscrollVelocity( - const ScrollbarLayerImplBase* scrollbar, - gfx::ScrollOffset scroll_offset) const; + float InitialDeltaToAutoscrollVelocity(gfx::ScrollOffset scroll_offset) const; // Returns the hit tested ScrollbarPart based on the position_in_widget. ScrollbarPart GetScrollbarPartFromPointerDown( - const ScrollbarLayerImplBase* scrollbar, - const gfx::PointF position_in_widget); + const gfx::PointF position_in_widget) const; // Returns scroll offsets based on which ScrollbarPart was hit tested. gfx::ScrollOffset GetScrollOffsetForScrollbarPart( - const ScrollbarLayerImplBase* scrollbar, const ScrollbarPart scrollbar_part, - const bool shift_modifier); + const bool jump_key_modifier) const; // Returns the rect for the ScrollbarPart. - gfx::Rect GetRectForScrollbarPart(const ScrollbarLayerImplBase* scrollbar, - const ScrollbarPart scrollbar_part); + gfx::Rect GetRectForScrollbarPart(const ScrollbarPart scrollbar_part) const; - LayerImpl* GetLayerHitByPoint(const gfx::PointF position_in_widget); - int GetScrollDeltaForScrollbarPart(const ScrollbarLayerImplBase* scrollbar, - const ScrollbarPart scrollbar_part, - const bool shift_modifier); + LayerImpl* GetLayerHitByPoint(const gfx::PointF position_in_widget) const; + int GetScrollDeltaForScrollbarPart(const ScrollbarPart scrollbar_part, + const bool jump_key_modifier) const; // Makes position_in_widget relative to the scrollbar. - gfx::PointF GetScrollbarRelativePosition( - const ScrollbarLayerImplBase* scrollbar, - const gfx::PointF position_in_widget, - bool* clipped); + gfx::PointF GetScrollbarRelativePosition(const gfx::PointF position_in_widget, + bool* clipped) const; // Decides if the scroller should snap to the offset that it was originally at // (i.e the offset before the thumb drag). - bool SnapToDragOrigin(const ScrollbarLayerImplBase* scrollbar, - const gfx::PointF pointer_position_in_widget); + bool SnapToDragOrigin(const gfx::PointF pointer_position_in_widget) const; // Decides whether a track autoscroll should be aborted (or restarted) due to // the thumb reaching the pointer or the pointer leaving (or re-entering) the @@ -233,22 +238,24 @@ class CC_EXPORT ScrollbarController { // Shift (or "Option" in case of Mac) + click is expected to do a non-animated // jump to a certain offset. - float GetScrollDeltaForAbsoluteJump(const ScrollbarLayerImplBase* scrollbar); + float GetScrollDeltaForAbsoluteJump() const; // Determines if the delta needs to be animated. ui::ScrollGranularity Granularity(const ScrollbarPart scrollbar_part, - bool shift_modifier); + bool jump_key_modifier) const; // Calculates the delta based on position_in_widget and drag_origin. int GetScrollDeltaForDragPosition( - const ScrollbarLayerImplBase* scrollbar, - const gfx::PointF pointer_position_in_widget); + const gfx::PointF pointer_position_in_widget) const; // Returns the ratio of the scroller length to the scrollbar length. This is // needed to scale the scroll delta for thumb drag. - float GetScrollerToScrollbarRatio(const ScrollbarLayerImplBase* scrollbar); + float GetScrollerToScrollbarRatio() const; + + int GetViewportLength() const; - int GetViewportLength(const ScrollbarLayerImplBase* scrollbar) const; + // Returns the pixel delta for a percent-based scroll of the scrollbar + int GetScrollDeltaForPercentBasedScroll() const; LayerTreeHostImpl* layer_tree_host_impl_; diff --git a/chromium/cc/input/touch_action.h b/chromium/cc/input/touch_action.h index f00d263acea..e873bd02d62 100644 --- a/chromium/cc/input/touch_action.h +++ b/chromium/cc/input/touch_action.h @@ -8,7 +8,7 @@ #include <cstdlib> #include <string> -#include "base/logging.h" +#include "base/notreached.h" namespace cc { diff --git a/chromium/cc/layers/deadline_policy.h b/chromium/cc/layers/deadline_policy.h index 6c3b0063046..6a461e3c235 100644 --- a/chromium/cc/layers/deadline_policy.h +++ b/chromium/cc/layers/deadline_policy.h @@ -7,7 +7,7 @@ #include <cstdint> -#include "base/logging.h" +#include "base/check.h" #include "base/optional.h" #include "cc/cc_export.h" diff --git a/chromium/cc/layers/draw_properties.h b/chromium/cc/layers/draw_properties.h index b241728724c..d5a0a7d84a4 100644 --- a/chromium/cc/layers/draw_properties.h +++ b/chromium/cc/layers/draw_properties.h @@ -53,9 +53,9 @@ struct CC_EXPORT DrawProperties { // the layer's coordinate space. gfx::Rect visible_layer_rect; - // In target surface space, the rect that encloses the clipped, drawable - // content of the layer. - gfx::Rect drawable_content_rect; + // In target surface space, the rect that encloses the clipped, visible, + // and drawable content of the layer. + gfx::Rect visible_drawable_content_rect; // In target surface space, the original rect that clipped this layer. This // value is used to avoid unnecessarily changing GL scissor state. diff --git a/chromium/cc/layers/heads_up_display_layer_impl.cc b/chromium/cc/layers/heads_up_display_layer_impl.cc index 6851763975f..b539a5da7c7 100644 --- a/chromium/cc/layers/heads_up_display_layer_impl.cc +++ b/chromium/cc/layers/heads_up_display_layer_impl.cc @@ -10,6 +10,7 @@ #include <algorithm> #include <vector> +#include "base/logging.h" #include "base/memory/shared_memory_mapping.h" #include "base/numerics/safe_conversions.h" #include "base/optional.h" @@ -19,6 +20,7 @@ #include "base/trace_event/trace_event.h" #include "base/trace_event/traced_value.h" #include "cc/debug/debug_colors.h" +#include "cc/metrics/dropped_frame_counter.h" #include "cc/paint/display_item_list.h" #include "cc/paint/paint_canvas.h" #include "cc/paint/paint_flags.h" @@ -27,7 +29,6 @@ #include "cc/paint/skia_paint_canvas.h" #include "cc/raster/scoped_gpu_raster.h" #include "cc/resources/memory_history.h" -#include "cc/trees/frame_rate_counter.h" #include "cc/trees/layer_tree_frame_sink.h" #include "cc/trees/layer_tree_host_impl.h" #include "cc/trees/layer_tree_impl.h" @@ -88,27 +89,9 @@ class DummyImageProvider : public ImageProvider { } // namespace -HeadsUpDisplayLayerImpl::Graph::Graph(double indicator_value, - double start_upper_bound) - : value(0.0), - min(0.0), - max(0.0), - current_upper_bound(start_upper_bound), - default_upper_bound(start_upper_bound), - indicator(indicator_value) {} - -double HeadsUpDisplayLayerImpl::Graph::UpdateUpperBound() { - double target_upper_bound = std::max(max, default_upper_bound); - current_upper_bound += (target_upper_bound - current_upper_bound) * 0.5; - return current_upper_bound; -} - HeadsUpDisplayLayerImpl::HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl, int id) - : LayerImpl(tree_impl, id), - internal_contents_scale_(1.f), - fps_graph_(60.0, 80.0), - paint_time_graph_(16.0, 48.0) {} + : LayerImpl(tree_impl, id) {} HeadsUpDisplayLayerImpl::~HeadsUpDisplayLayerImpl() { ReleaseResources(); @@ -550,18 +533,8 @@ void HeadsUpDisplayLayerImpl::UpdateHudContents() { time_of_last_graph_update_ = now; if (debug_state.show_fps_counter) { - FrameRateCounter* fps_counter = layer_tree_impl()->frame_rate_counter(); - fps_graph_.value = fps_counter->GetAverageFPS(); - fps_counter->GetMinAndMaxFPS(&fps_graph_.min, &fps_graph_.max); - current_throughput_ = layer_tree_impl()->current_universal_throughput(); - if (current_throughput_.has_value()) { - if (!max_throughput.has_value() || - current_throughput_.value() > max_throughput.value()) - max_throughput = current_throughput_; - if (!min_throughput.has_value() || - current_throughput_.value() < min_throughput.value()) - min_throughput = current_throughput_; - } + throughput_value_ = + layer_tree_impl()->dropped_frame_counter()->GetAverageThroughput(); } if (debug_state.ShowMemoryStats()) { @@ -572,9 +545,6 @@ void HeadsUpDisplayLayerImpl::UpdateHudContents() { memory_entry_ = MemoryHistory::Entry(); } } - - fps_graph_.UpdateUpperBound(); - paint_time_graph_.UpdateUpperBound(); } void HeadsUpDisplayLayerImpl::DrawHudContents(PaintCanvas* canvas) { @@ -597,8 +567,8 @@ void HeadsUpDisplayLayerImpl::DrawHudContents(PaintCanvas* canvas) { return; } - SkRect area = - DrawFPSDisplay(canvas, layer_tree_impl()->frame_rate_counter(), 0, 0); + SkRect area = DrawFrameThroughputDisplay( + canvas, layer_tree_impl()->dropped_frame_counter(), 0, 0); area = DrawGpuRasterizationStatus(canvas, 0, area.bottom(), std::max<SkScalar>(area.width(), 150)); @@ -652,30 +622,18 @@ void HeadsUpDisplayLayerImpl::DrawGraphBackground(PaintCanvas* canvas, void HeadsUpDisplayLayerImpl::DrawGraphLines(PaintCanvas* canvas, PaintFlags* flags, - const SkRect& bounds, - const Graph& graph) const { + const SkRect& bounds) const { // Draw top and bottom line. flags->setColor(DebugColors::HUDSeparatorLineColor()); canvas->drawLine(bounds.left(), bounds.top() - 1, bounds.right(), bounds.top() - 1, *flags); canvas->drawLine(bounds.left(), bounds.bottom(), bounds.right(), bounds.bottom(), *flags); - - // Draw indicator line (additive blend mode to increase contrast when drawn on - // top of graph). - flags->setColor(DebugColors::HUDIndicatorLineColor()); - flags->setBlendMode(SkBlendMode::kPlus); - const double indicator_top = - bounds.height() * (1.0 - graph.indicator / graph.current_upper_bound) - - 1.0; - canvas->drawLine(bounds.left(), bounds.top() + indicator_top, bounds.right(), - bounds.top() + indicator_top, *flags); - flags->setBlendMode(SkBlendMode::kSrcOver); } -SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( +SkRect HeadsUpDisplayLayerImpl::DrawFrameThroughputDisplay( PaintCanvas* canvas, - const FrameRateCounter* fps_counter, + const DroppedFrameCounter* dropped_frame_counter, int right, int top) const { const int kPadding = 4; @@ -685,39 +643,35 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( const int kFontHeight = 12; const int kGraphWidth = - base::saturated_cast<int>(fps_counter->time_stamp_history_size()) - 2; + base::saturated_cast<int>(dropped_frame_counter->frame_history_size()); const int kGraphHeight = 40; - const int kHistogramWidth = 37; - - int width = kGraphWidth + kHistogramWidth + 4 * kPadding; - int height = - 2 * kTitleFontHeight + 2 * kFontHeight + kGraphHeight + 10 * kPadding + 2; + int width = kGraphWidth + 4 * kPadding; + int height = kTitleFontHeight + kFontHeight + kGraphHeight + 6 * kPadding + 2; int left = 0; SkRect area = SkRect::MakeXYWH(left, top, width, height); PaintFlags flags; DrawGraphBackground(canvas, &flags, area); - SkRect title_bounds = SkRect::MakeXYWH( - left + kPadding, top + kPadding, kGraphWidth + kHistogramWidth + kGap + 2, - kTitleFontHeight); + SkRect title_bounds = + SkRect::MakeXYWH(left + kPadding, top + kPadding, kGraphWidth + kGap + 2, + kTitleFontHeight); SkRect text_bounds = SkRect::MakeXYWH(left + kPadding, title_bounds.bottom() + 2 * kPadding, - kGraphWidth + kHistogramWidth + kGap + 2, kFontHeight); + kGraphWidth + kGap + 2, kFontHeight); SkRect graph_bounds = SkRect::MakeXYWH(left + kPadding, text_bounds.bottom() + 2 * kPadding, kGraphWidth, kGraphHeight); - SkRect histogram_bounds = - SkRect::MakeXYWH(graph_bounds.right() + kGap, graph_bounds.top(), - kHistogramWidth, kGraphHeight); // Draw the fps meter. - const std::string title("Frame Rate"); - const std::string value_text = - base::StringPrintf("%5.1f fps", fps_graph_.value); - const std::string min_max_text = - base::StringPrintf("%.0f-%.0f", fps_graph_.min, fps_graph_.max); + const std::string title("Frames"); + const std::string value_text = base::StringPrintf("%d %%", throughput_value_); + const std::string dropped_frames_text = + base::StringPrintf("%zu (%zu m) dropped of %zu", + dropped_frame_counter->total_compositor_dropped(), + dropped_frame_counter->total_main_dropped(), + dropped_frame_counter->total_frames()); VLOG(1) << value_text; @@ -728,105 +682,40 @@ SkRect HeadsUpDisplayLayerImpl::DrawFPSDisplay( flags.setColor(DebugColors::FPSDisplayTextAndGraphColor()); DrawText(canvas, flags, value_text, TextAlign::kLeft, kFontHeight, text_bounds.left(), text_bounds.bottom()); - DrawText(canvas, flags, min_max_text, TextAlign::kRight, kFontHeight, + DrawText(canvas, flags, dropped_frames_text, TextAlign::kRight, kFontHeight, text_bounds.right(), text_bounds.bottom()); - DrawGraphLines(canvas, &flags, graph_bounds, fps_graph_); - - // Draw the throughput meter. - int current_top = histogram_bounds.bottom() + kPadding; - const std::string throughput_title("Throughput"); - const std::string throughput_value_text = - current_throughput_.has_value() - ? base::StringPrintf("%d %%", current_throughput_.value()) - : base::StringPrintf("n/a"); - - VLOG(1) << throughput_value_text; - - flags.setColor(DebugColors::HUDTitleColor()); - DrawText(canvas, flags, throughput_title, TextAlign::kLeft, kTitleFontHeight, - title_bounds.left(), title_bounds.bottom() + current_top); - - flags.setColor(DebugColors::FPSDisplayTextAndGraphColor()); - DrawText(canvas, flags, throughput_value_text, TextAlign::kLeft, kFontHeight, - text_bounds.left(), text_bounds.bottom() + current_top); - if (min_throughput.has_value()) { - const std::string throughput_min_max_text = base::StringPrintf( - "%d-%d", min_throughput.value(), max_throughput.value()); - DrawText(canvas, flags, throughput_min_max_text, TextAlign::kRight, - kFontHeight, text_bounds.right(), - text_bounds.bottom() + current_top); - } - - // Collect fps graph and histogram data. - SkPath path; - - const int kHistogramSize = 20; - double histogram[kHistogramSize] = {1.0}; - double max_bucket_value = 1.0; - - for (FrameRateCounter::RingBufferType::Iterator it = --fps_counter->end(); it; - --it) { - base::TimeDelta delta = fps_counter->RecentFrameInterval(it.index() + 1); - - // Skip this particular instantaneous frame rate if it is not likely to have - // been valid. - if (!fps_counter->IsBadFrameInterval(delta)) { - double fps = 1.0 / delta.InSecondsF(); - - // Clamp the FPS to the range we want to plot visually. - double p = fps / fps_graph_.current_upper_bound; - if (p > 1.0) - p = 1.0; - - // Plot this data point. - SkPoint cur = - SkPoint::Make(graph_bounds.left() + it.index(), - graph_bounds.bottom() - p * graph_bounds.height()); - if (path.isEmpty()) - path.moveTo(cur); - else - path.lineTo(cur); - - // Use the fps value to find the right bucket in the histogram. - int bucket_index = floor(p * (kHistogramSize - 1)); - - // Add the delta time to take the time spent at that fps rate into - // account. - histogram[bucket_index] += delta.InSecondsF(); - max_bucket_value = std::max(histogram[bucket_index], max_bucket_value); - } - } - - // Draw FPS histogram. - flags.setColor(DebugColors::HUDSeparatorLineColor()); - canvas->drawLine(histogram_bounds.left() - 1, histogram_bounds.top() - 1, - histogram_bounds.left() - 1, histogram_bounds.bottom() + 1, - flags); - canvas->drawLine(histogram_bounds.right() + 1, histogram_bounds.top() - 1, - histogram_bounds.right() + 1, histogram_bounds.bottom() + 1, - flags); - - flags.setColor(DebugColors::FPSDisplayTextAndGraphColor()); - const double bar_height = histogram_bounds.height() / kHistogramSize; - - for (int i = kHistogramSize - 1; i >= 0; --i) { - if (histogram[i] > 0) { - double bar_width = - histogram[i] / max_bucket_value * histogram_bounds.width(); - canvas->drawRect( - SkRect::MakeXYWH(histogram_bounds.left(), - histogram_bounds.bottom() - (i + 1) * bar_height, - bar_width, 1), - flags); - } + DrawGraphLines(canvas, &flags, graph_bounds); + + // Collect the frames graph data. + SkPath good_path; + SkPath dropped_path; + SkPath partial_path; + for (auto it = --dropped_frame_counter->end(); it; --it) { + const auto state = **it; + int x = graph_bounds.left() + it.index(); + SkPath& path = state == DroppedFrameCounter::kFrameStateDropped + ? dropped_path + : state == DroppedFrameCounter::kFrameStateComplete + ? good_path + : partial_path; + path.moveTo(x, graph_bounds.top()); + path.lineTo(x, graph_bounds.bottom()); } // Draw FPS graph. flags.setAntiAlias(true); flags.setStyle(PaintFlags::kStroke_Style); flags.setStrokeWidth(1); - canvas->drawPath(path, flags); + + flags.setColor(SkColorSetA(SK_ColorGREEN, 128)); + canvas->drawPath(good_path, flags); + + flags.setColor(SkColorSetA(SK_ColorRED, 128)); + canvas->drawPath(dropped_path, flags); + + flags.setColor(SkColorSetA(SK_ColorYELLOW, 255)); + canvas->drawPath(partial_path, flags); return area; } diff --git a/chromium/cc/layers/heads_up_display_layer_impl.h b/chromium/cc/layers/heads_up_display_layer_impl.h index 323da1fff87..417d5a0d9b8 100644 --- a/chromium/cc/layers/heads_up_display_layer_impl.h +++ b/chromium/cc/layers/heads_up_display_layer_impl.h @@ -26,7 +26,7 @@ class ClientResourceProvider; } namespace cc { -class FrameRateCounter; +class DroppedFrameCounter; class LayerTreeFrameSink; class PaintCanvas; class PaintFlags; @@ -76,24 +76,6 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl { void PushPropertiesTo(LayerImpl* layer) override; private: - class Graph { - public: - Graph(double indicator_value, double start_upper_bound); - - // Eases the upper bound, which limits what is currently visible in the - // graph, so that the graph always scales to either it's max or - // default_upper_bound. - double UpdateUpperBound(); - - double value; - double min; - double max; - - double current_upper_bound; - const double default_upper_bound; - const double indicator; - }; - HeadsUpDisplayLayerImpl(LayerTreeImpl* tree_impl, int id); const char* LayerTypeAsString() const override; @@ -120,13 +102,13 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl { const SkRect& bounds) const; void DrawGraphLines(PaintCanvas* canvas, PaintFlags* flags, - const SkRect& bounds, - const Graph& graph) const; + const SkRect& bounds) const; - SkRect DrawFPSDisplay(PaintCanvas* canvas, - const FrameRateCounter* fps_counter, - int right, - int top) const; + SkRect DrawFrameThroughputDisplay( + PaintCanvas* canvas, + const DroppedFrameCounter* dropped_frame_counter, + int right, + int top) const; SkRect DrawMemoryDisplay(PaintCanvas* canvas, int top, int right, @@ -154,21 +136,15 @@ class CC_EXPORT HeadsUpDisplayLayerImpl : public LayerImpl { sk_sp<SkTypeface> typeface_; std::vector<gfx::Rect> layout_shift_rects_; - float internal_contents_scale_; + float internal_contents_scale_ = 1.0f; gfx::Size internal_content_bounds_; - Graph fps_graph_; - Graph paint_time_graph_; + uint32_t throughput_value_ = 0.0f; MemoryHistory::Entry memory_entry_; int paint_rects_fade_step_ = 0; int layout_shift_rects_fade_step_ = 0; std::vector<DebugRect> paint_rects_; std::vector<DebugRect> layout_shift_debug_rects_; - base::Optional<int> current_throughput_; - // The worst and best throughput we have seen so far, they either both have no - // value, or both have value. - base::Optional<int> min_throughput; - base::Optional<int> max_throughput; base::TimeTicks time_of_last_graph_update_; }; diff --git a/chromium/cc/layers/layer.cc b/chromium/cc/layers/layer.cc index c354081f17b..7b74ae2da3c 100644 --- a/chromium/cc/layers/layer.cc +++ b/chromium/cc/layers/layer.cc @@ -78,6 +78,7 @@ Layer::Inputs::Inputs(int layer_id) : layer_id(layer_id), hit_testable(false), contents_opaque(false), + contents_opaque_for_text(false), is_drawable(false), double_sided(true), has_will_change_transform_hint(false), @@ -804,11 +805,21 @@ void Layer::SetContentsOpaque(bool opaque) { if (inputs_.contents_opaque == opaque) return; inputs_.contents_opaque = opaque; + inputs_.contents_opaque_for_text = opaque; SetNeedsCommit(); SetSubtreePropertyChanged(); SetPropertyTreesNeedRebuild(); } +void Layer::SetContentsOpaqueForText(bool opaque) { + DCHECK(IsPropertyChangeAllowed()); + if (inputs_.contents_opaque_for_text == opaque) + return; + DCHECK(!contents_opaque() || opaque); + inputs_.contents_opaque_for_text = opaque; + SetNeedsCommit(); +} + void Layer::SetPosition(const gfx::PointF& position) { DCHECK(!layer_tree_host_ || !layer_tree_host_->IsUsingLayerLists()); @@ -1321,6 +1332,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) { layer->SetWheelEventHandlerRegion(Region()); } layer->SetContentsOpaque(inputs_.contents_opaque); + layer->SetContentsOpaqueForText(inputs_.contents_opaque_for_text); layer->SetShouldCheckBackfaceVisibility(should_check_backface_visibility_); layer->UpdateScrollable(); diff --git a/chromium/cc/layers/layer.h b/chromium/cc/layers/layer.h index 43debb199e8..a2da20587d1 100644 --- a/chromium/cc/layers/layer.h +++ b/chromium/cc/layers/layer.h @@ -333,9 +333,24 @@ class CC_EXPORT Layer : public base::RefCounted<Layer> { // must be opaque or visual errors can occur. This applies only to this layer // and not to children, and does not imply the layer should be composited // opaquely, as effects may be applied such as opacity() or filters(). + // Note that this also calls SetContentsOpaqueForText(opaque) internally. + // To override a different contents_opaque_for_text, the client should call + // SetContentsOpaqueForText() after SetContentsOpaque(). void SetContentsOpaque(bool opaque); bool contents_opaque() const { return inputs_.contents_opaque; } + // Whether the contents area containing text is known to be opaque. + // For example, blink will SetContentsOpaque(false) but + // SetContentsOpaqueForText(true) for the following case: + // <div style="overflow: hidden; border-radius: 10px; background: white"> + // TEXT + // </div> + // See also the note for SetContentsOpaque(). + void SetContentsOpaqueForText(bool opaque); + bool contents_opaque_for_text() const { + return inputs_.contents_opaque_for_text; + } + // Set or get whether this layer should be a hit test target void SetHitTestable(bool should_hit_test); virtual bool HitTestable() const; @@ -829,6 +844,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer> { bool hit_testable : 1; bool contents_opaque : 1; + bool contents_opaque_for_text : 1; bool is_drawable : 1; bool double_sided : 1; diff --git a/chromium/cc/layers/layer_impl.cc b/chromium/cc/layers/layer_impl.cc index bb1c93f2538..318c2cbc1ee 100644 --- a/chromium/cc/layers/layer_impl.cc +++ b/chromium/cc/layers/layer_impl.cc @@ -55,6 +55,7 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, layer_property_changed_from_property_trees_(false), may_contain_video_(false), contents_opaque_(false), + contents_opaque_for_text_(false), should_check_backface_visibility_(false), draws_content_(false), contributes_to_drawn_render_surface_(false), @@ -374,6 +375,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) { layer->has_transform_node_ = has_transform_node_; layer->offset_to_transform_parent_ = offset_to_transform_parent_; layer->contents_opaque_ = contents_opaque_; + layer->contents_opaque_for_text_ = contents_opaque_for_text_; layer->may_contain_video_ = may_contain_video_; layer->should_check_backface_visibility_ = should_check_backface_visibility_; layer->draws_content_ = draws_content_; @@ -571,6 +573,12 @@ SkColor LayerImpl::SafeOpaqueBackgroundColor() const { void LayerImpl::SetContentsOpaque(bool opaque) { contents_opaque_ = opaque; + contents_opaque_for_text_ = opaque; +} + +void LayerImpl::SetContentsOpaqueForText(bool opaque) { + DCHECK(!contents_opaque_ || opaque); + contents_opaque_for_text_ = opaque; } float LayerImpl::Opacity() const { diff --git a/chromium/cc/layers/layer_impl.h b/chromium/cc/layers/layer_impl.h index 95eb4828df8..006057b5b12 100644 --- a/chromium/cc/layers/layer_impl.h +++ b/chromium/cc/layers/layer_impl.h @@ -14,7 +14,7 @@ #include <string> #include <vector> -#include "base/logging.h" +#include "base/check.h" #include "base/memory/ptr_util.h" #include "cc/base/region.h" #include "cc/base/synced_property.h" @@ -165,8 +165,12 @@ class CC_EXPORT LayerImpl { // non-opaque color. Tries to return background_color(), if possible. SkColor SafeOpaqueBackgroundColor() const; + // See Layer::SetContentsOpaque() and SetContentsOpaqueForText() for the + // relationship between the two flags. void SetContentsOpaque(bool opaque); bool contents_opaque() const { return contents_opaque_; } + void SetContentsOpaqueForText(bool opaque); + bool contents_opaque_for_text() const { return contents_opaque_for_text_; } float Opacity() const; @@ -221,8 +225,8 @@ class CC_EXPORT LayerImpl { return draw_properties_.screen_space_transform_is_animating; } gfx::Rect clip_rect() const { return draw_properties_.clip_rect; } - gfx::Rect drawable_content_rect() const { - return draw_properties_.drawable_content_rect; + gfx::Rect visible_drawable_content_rect() const { + return draw_properties_.visible_drawable_content_rect; } gfx::Rect visible_layer_rect() const { return draw_properties_.visible_layer_rect; @@ -475,6 +479,7 @@ class CC_EXPORT LayerImpl { bool may_contain_video_ : 1; bool contents_opaque_ : 1; + bool contents_opaque_for_text_ : 1; bool should_check_backface_visibility_ : 1; bool draws_content_ : 1; bool contributes_to_drawn_render_surface_ : 1; diff --git a/chromium/cc/layers/layer_unittest.cc b/chromium/cc/layers/layer_unittest.cc index c49c99b106f..1d975284495 100644 --- a/chromium/cc/layers/layer_unittest.cc +++ b/chromium/cc/layers/layer_unittest.cc @@ -17,6 +17,7 @@ #include "cc/layers/picture_layer.h" #include "cc/layers/solid_color_scrollbar_layer.h" #include "cc/test/animation_test_common.h" +#include "cc/test/cc_test_suite.h" #include "cc/test/fake_content_layer_client.h" #include "cc/test/fake_impl_task_runner_provider.h" #include "cc/test/fake_layer_tree_host.h" @@ -1388,15 +1389,23 @@ TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) { viz::CopyOutputRequest::ResultFormat::RGBA_BITMAP, base::BindOnce(&ReceiveCopyOutputResult, &result_count)); layer->RequestCopyOfOutput(std::move(request)); + // Because RequestCopyOfOutput could run as a PostTask to return results + // RunUntilIdle() to ensure that the result is not returned yet. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(0, result_count); request = std::make_unique<viz::CopyOutputRequest>( viz::CopyOutputRequest::ResultFormat::RGBA_BITMAP, base::BindOnce(&ReceiveCopyOutputResult, &result_count)); layer->RequestCopyOfOutput(std::move(request)); + // Because RequestCopyOfOutput could run as a PostTask to return results + // RunUntilIdle() to ensure that the result is not returned yet. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(0, result_count); // When the layer is destroyed, expect both requests to be aborted. layer = nullptr; + // Wait for any posted tasks to run so the results will be returned. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(2, result_count); layer = Layer::Create(); @@ -1412,6 +1421,9 @@ TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) { &did_receive_first_result_from_this_source)); request->set_source(kArbitrarySourceId1); layer->RequestCopyOfOutput(std::move(request)); + // Because RequestCopyOfOutput could run as a PostTask to return results + // RunUntilIdle() to ensure that the result is not returned yet. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(0, did_receive_first_result_from_this_source); // Make a request from a different source. int did_receive_result_from_different_source = 0; @@ -1421,6 +1433,9 @@ TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) { &did_receive_result_from_different_source)); request->set_source(kArbitrarySourceId2); layer->RequestCopyOfOutput(std::move(request)); + // Because RequestCopyOfOutput could run as a PostTask to return results + // RunUntilIdle() to ensure that the result is not returned yet. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(0, did_receive_result_from_different_source); // Make a request without specifying the source. int did_receive_result_from_anonymous_source = 0; @@ -1429,6 +1444,9 @@ TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) { base::BindOnce(&ReceiveCopyOutputResult, &did_receive_result_from_anonymous_source)); layer->RequestCopyOfOutput(std::move(request)); + // Because RequestCopyOfOutput could run as a PostTask to return results + // RunUntilIdle() to ensure that the result is not returned yet. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(0, did_receive_result_from_anonymous_source); // Make the second request from |kArbitrarySourceId1|. int did_receive_second_result_from_this_source = 0; @@ -1439,6 +1457,8 @@ TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) { request->set_source(kArbitrarySourceId1); layer->RequestCopyOfOutput( std::move(request)); // First request to be aborted. + // Wait for any posted tasks to run so the results will be returned. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(1, did_receive_first_result_from_this_source); EXPECT_EQ(0, did_receive_result_from_different_source); EXPECT_EQ(0, did_receive_result_from_anonymous_source); @@ -1446,6 +1466,8 @@ TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) { // When the layer is destroyed, the other three requests should be aborted. layer = nullptr; + // Wait for any posted tasks to run so the results will be returned. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(1, did_receive_first_result_from_this_source); EXPECT_EQ(1, did_receive_result_from_different_source); EXPECT_EQ(1, did_receive_result_from_anonymous_source); @@ -1507,7 +1529,7 @@ TEST_F(LayerTest, SetLayerTreeHostNotUsingLayerListsManagesElementId) { // Expect additional calls due to has-animation check and initialization // of keyframes. - EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(7); + EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(3); scoped_refptr<AnimationTimeline> timeline = AnimationTimeline::Create(AnimationIdProvider::NextTimelineId()); animation_host_->AddAnimationTimeline(timeline); @@ -1526,6 +1548,19 @@ TEST_F(LayerTest, SetLayerTreeHostNotUsingLayerListsManagesElementId) { EXPECT_EQ(nullptr, layer_tree_host_->LayerByElementId(element_id)); } +// Triggering a commit to push animation counts and raf presence to the +// compositor is expensive and updated counts can wait until the next +// commit to be pushed. See https://crbug.com/1083244. +TEST_F(LayerTest, PushAnimationCountsLazily) { + EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0); + animation_host_->SetAnimationCounts(0, /* current_frame_had_raf = */ true, + /* next_frame_has_pending_raf = */ true); + EXPECT_FALSE(host_impl_.animation_host()->CurrentFrameHadRAF()); + EXPECT_FALSE(animation_host_->needs_push_properties()); + animation_host_->PushPropertiesTo(host_impl_.animation_host()); + EXPECT_TRUE(host_impl_.animation_host()->CurrentFrameHadRAF()); +} + TEST_F(LayerTest, SetElementIdNotUsingLayerLists) { scoped_refptr<Layer> test_layer = Layer::Create(); test_layer->SetLayerTreeHost(layer_tree_host_.get()); diff --git a/chromium/cc/layers/mirror_layer_impl.cc b/chromium/cc/layers/mirror_layer_impl.cc index 7a916bf5d69..5751ccb53b2 100644 --- a/chromium/cc/layers/mirror_layer_impl.cc +++ b/chromium/cc/layers/mirror_layer_impl.cc @@ -56,8 +56,7 @@ void MirrorLayerImpl::AppendQuads(viz::RenderPass* render_pass, quad->SetNew(shared_quad_state, content_rect, unoccluded_content_rect, mirrored_layer_id_, mask_resource_id, mask_uv_rect, mask_texture_size, mirrored_effect_node->surface_contents_scale, - mirrored_effect_node->filters_origin, - gfx::RectF(gfx::Rect(content_rect.size())), + gfx::PointF(), gfx::RectF(gfx::Rect(content_rect.size())), !layer_tree_impl()->settings().enable_edge_anti_aliasing, 0.f); } diff --git a/chromium/cc/layers/painted_scrollbar_layer.cc b/chromium/cc/layers/painted_scrollbar_layer.cc index 84f6b872302..2be635c50e2 100644 --- a/chromium/cc/layers/painted_scrollbar_layer.cc +++ b/chromium/cc/layers/painted_scrollbar_layer.cc @@ -40,6 +40,7 @@ PaintedScrollbarLayer::PaintedScrollbarLayer(scoped_refptr<Scrollbar> scrollbar) internal_contents_scale_(1.f), painted_opacity_(scrollbar_->Opacity()), has_thumb_(scrollbar_->HasThumb()), + jump_on_track_click_(scrollbar_->JumpOnTrackClick()), supports_drag_snap_back_(scrollbar_->SupportsDragSnapBack()), is_overlay_(scrollbar_->IsOverlay()) {} @@ -58,6 +59,7 @@ void PaintedScrollbarLayer::PushPropertiesTo(LayerImpl* layer) { scrollbar_layer->set_internal_contents_scale_and_bounds( internal_contents_scale_, internal_content_bounds_); + scrollbar_layer->SetJumpOnTrackClick(jump_on_track_click_); scrollbar_layer->SetSupportsDragSnapBack(supports_drag_snap_back_); scrollbar_layer->SetBackButtonRect(back_button_rect_); scrollbar_layer->SetForwardButtonRect(forward_button_rect_); @@ -112,6 +114,7 @@ void PaintedScrollbarLayer::UpdateThumbAndTrackGeometry() { DCHECK_EQ(is_overlay_, scrollbar_->IsOverlay()); DCHECK_EQ(orientation(), scrollbar_->Orientation()); + UpdateProperty(scrollbar_->JumpOnTrackClick(), &jump_on_track_click_); UpdateProperty(scrollbar_->TrackRect(), &track_rect_); UpdateProperty(scrollbar_->BackButtonRect(), &back_button_rect_); UpdateProperty(scrollbar_->ForwardButtonRect(), &forward_button_rect_); diff --git a/chromium/cc/layers/painted_scrollbar_layer.h b/chromium/cc/layers/painted_scrollbar_layer.h index 191c37d8e5a..930c614071e 100644 --- a/chromium/cc/layers/painted_scrollbar_layer.h +++ b/chromium/cc/layers/painted_scrollbar_layer.h @@ -86,6 +86,7 @@ class CC_EXPORT PaintedScrollbarLayer : public ScrollbarLayerBase { gfx::Rect forward_button_rect_; float painted_opacity_; bool has_thumb_; + bool jump_on_track_click_; const bool supports_drag_snap_back_; const bool is_overlay_; diff --git a/chromium/cc/layers/painted_scrollbar_layer_impl.cc b/chromium/cc/layers/painted_scrollbar_layer_impl.cc index 70da5b1be8f..6d36154b803 100644 --- a/chromium/cc/layers/painted_scrollbar_layer_impl.cc +++ b/chromium/cc/layers/painted_scrollbar_layer_impl.cc @@ -43,6 +43,7 @@ PaintedScrollbarLayerImpl::PaintedScrollbarLayerImpl( thumb_ui_resource_id_(0), painted_opacity_(1.f), internal_contents_scale_(1.f), + jump_on_track_click_(false), supports_drag_snap_back_(false), thumb_thickness_(0), thumb_length_(0) {} @@ -65,6 +66,7 @@ void PaintedScrollbarLayerImpl::PushPropertiesTo(LayerImpl* layer) { scrollbar_layer->set_internal_contents_scale_and_bounds( internal_contents_scale_, internal_content_bounds_); + scrollbar_layer->SetJumpOnTrackClick(jump_on_track_click_); scrollbar_layer->SetSupportsDragSnapBack(supports_drag_snap_back_); scrollbar_layer->SetThumbThickness(thumb_thickness_); scrollbar_layer->SetThumbLength(thumb_length_); @@ -162,6 +164,17 @@ gfx::Rect PaintedScrollbarLayerImpl::GetEnclosingRectInTargetSpace() const { return GetScaledEnclosingRectInTargetSpace(internal_contents_scale_); } +void PaintedScrollbarLayerImpl::SetJumpOnTrackClick(bool jump_on_track_click) { + if (jump_on_track_click_ == jump_on_track_click) + return; + jump_on_track_click_ = jump_on_track_click; + NoteLayerPropertyChanged(); +} + +bool PaintedScrollbarLayerImpl::JumpOnTrackClick() const { + return jump_on_track_click_; +} + void PaintedScrollbarLayerImpl::SetSupportsDragSnapBack( bool supports_drag_snap_back) { if (supports_drag_snap_back_ == supports_drag_snap_back) diff --git a/chromium/cc/layers/painted_scrollbar_layer_impl.h b/chromium/cc/layers/painted_scrollbar_layer_impl.h index e5035e1dc3b..eecf7c9aefd 100644 --- a/chromium/cc/layers/painted_scrollbar_layer_impl.h +++ b/chromium/cc/layers/painted_scrollbar_layer_impl.h @@ -38,6 +38,7 @@ class CC_EXPORT PaintedScrollbarLayerImpl : public ScrollbarLayerImplBase { AppendQuadsData* append_quads_data) override; gfx::Rect GetEnclosingRectInTargetSpace() const override; + void SetJumpOnTrackClick(bool jump_on_track_click); void SetSupportsDragSnapBack(bool supports_drag_snap_back); void SetBackButtonRect(gfx::Rect back_button_rect); void SetForwardButtonRect(gfx::Rect forward_button_rect); @@ -63,6 +64,7 @@ class CC_EXPORT PaintedScrollbarLayerImpl : public ScrollbarLayerImplBase { internal_content_bounds_ = content_bounds; } + bool JumpOnTrackClick() const override; bool SupportsDragSnapBack() const override; gfx::Rect BackButtonRect() const override; gfx::Rect ForwardButtonRect() const override; @@ -98,6 +100,7 @@ class CC_EXPORT PaintedScrollbarLayerImpl : public ScrollbarLayerImplBase { float internal_contents_scale_; gfx::Size internal_content_bounds_; + bool jump_on_track_click_; bool supports_drag_snap_back_; int thumb_thickness_; int thumb_length_; diff --git a/chromium/cc/layers/picture_image_layer.cc b/chromium/cc/layers/picture_image_layer.cc deleted file mode 100644 index 2208b11c6a1..00000000000 --- a/chromium/cc/layers/picture_image_layer.cc +++ /dev/null @@ -1,116 +0,0 @@ -// Copyright 2010 The Chromium 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 "cc/layers/picture_image_layer.h" - -#include <stddef.h> - -#include "cc/base/math_util.h" -#include "cc/layers/picture_layer_impl.h" -#include "cc/paint/paint_op_buffer.h" -#include "cc/trees/layer_tree_host.h" -#include "cc/trees/layer_tree_settings.h" - -namespace cc { - -scoped_refptr<PictureImageLayer> PictureImageLayer::Create() { - return base::WrapRefCounted(new PictureImageLayer()); -} - -PictureImageLayer::PictureImageLayer() : PictureLayer(this) {} - -PictureImageLayer::~PictureImageLayer() { - ClearClient(); -} - -bool PictureImageLayer::HasDrawableContent() const { - return image_ && PictureLayer::HasDrawableContent(); -} - -void PictureImageLayer::SetImage(PaintImage image, - const SkMatrix& matrix, - bool uses_width_as_height) { - // SetImage() currently gets called whenever there is any - // style change that affects the layer even if that change doesn't - // affect the actual contents of the image (e.g. a CSS animation). - // With this check in place we avoid unecessary texture uploads. - if (image_ == image && matrix_ == matrix && - uses_width_as_height_ == uses_width_as_height) { - return; - } - - image_ = std::move(image); - matrix_ = matrix; - uses_width_as_height_ = uses_width_as_height; - - int width = uses_width_as_height_ ? image_.height() : image_.width(); - int height = uses_width_as_height_ ? image_.width() : image_.height(); - picture_layer_inputs_.directly_composited_image_size = - gfx::Size(width, height); - - UpdateDrawsContent(HasDrawableContent()); - SetNeedsDisplay(); -} - -gfx::Rect PictureImageLayer::PaintableRegion() { - return gfx::Rect(bounds()); -} - -scoped_refptr<DisplayItemList> PictureImageLayer::PaintContentsToDisplayList( - ContentLayerClient::PaintingControlSetting painting_control) { - DCHECK(image_); - DCHECK_GT(image_.width(), 0); - DCHECK_GT(image_.height(), 0); - DCHECK(layer_tree_host()); - - gfx::Size image_size = - picture_layer_inputs_.directly_composited_image_size.value(); - float content_to_layer_scale_x = - static_cast<float>(bounds().width()) / image_size.width(); - float content_to_layer_scale_y = - static_cast<float>(bounds().height()) / image_size.height(); - - bool has_scale = !MathUtil::IsWithinEpsilon(content_to_layer_scale_x, 1.f) || - !MathUtil::IsWithinEpsilon(content_to_layer_scale_y, 1.f); - DCHECK(!has_scale); - bool needs_save = has_scale || !matrix_.isIdentity(); - - auto display_list = base::MakeRefCounted<DisplayItemList>(); - - display_list->StartPaint(); - - if (needs_save) - display_list->push<SaveOp>(); - - if (has_scale) { - display_list->push<ScaleOp>(content_to_layer_scale_x, - content_to_layer_scale_y); - } - - if (!matrix_.isIdentity()) - display_list->push<ConcatOp>(matrix_); - - // Because Android WebView resourceless software draw mode rasters directly - // to the root canvas, this draw must use the SkBlendMode::kSrcOver so that - // transparent images blend correctly. - display_list->push<DrawImageOp>(image_, 0.f, 0.f, nullptr); - - if (needs_save) - display_list->push<RestoreOp>(); - - display_list->EndPaintOfUnpaired(PaintableRegion()); - display_list->Finalize(); - - return display_list; -} - -bool PictureImageLayer::FillsBoundsCompletely() const { - return false; -} - -size_t PictureImageLayer::GetApproximateUnsharedMemoryUsage() const { - return 0; -} - -} // namespace cc diff --git a/chromium/cc/layers/picture_image_layer.h b/chromium/cc/layers/picture_image_layer.h deleted file mode 100644 index 92fddfad360..00000000000 --- a/chromium/cc/layers/picture_image_layer.h +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef CC_LAYERS_PICTURE_IMAGE_LAYER_H_ -#define CC_LAYERS_PICTURE_IMAGE_LAYER_H_ - -#include <stddef.h> - -#include "cc/cc_export.h" -#include "cc/layers/content_layer_client.h" -#include "cc/layers/picture_layer.h" -#include "cc/paint/paint_image.h" -#include "third_party/skia/include/core/SkRefCnt.h" -#include "ui/gfx/geometry/size.h" - -namespace cc { - -class CC_EXPORT PictureImageLayer : public PictureLayer, ContentLayerClient { - public: - static scoped_refptr<PictureImageLayer> Create(); - - PictureImageLayer(const PictureImageLayer&) = delete; - PictureImageLayer& operator=(const PictureImageLayer&) = delete; - - void SetImage(PaintImage image, - const SkMatrix& matrix, - bool uses_width_as_height); - - gfx::Rect PaintableRegion() override; - - // ContentLayerClient implementation. - scoped_refptr<DisplayItemList> PaintContentsToDisplayList( - ContentLayerClient::PaintingControlSetting painting_control) override; - bool FillsBoundsCompletely() const override; - size_t GetApproximateUnsharedMemoryUsage() const override; - - protected: - bool HasDrawableContent() const override; - - private: - PictureImageLayer(); - ~PictureImageLayer() override; - - PaintImage image_; - SkMatrix matrix_; - bool uses_width_as_height_; -}; - -} // namespace cc - -#endif // CC_LAYERS_PICTURE_IMAGE_LAYER_H_ diff --git a/chromium/cc/layers/picture_image_layer_unittest.cc b/chromium/cc/layers/picture_image_layer_unittest.cc deleted file mode 100644 index f02c127aa37..00000000000 --- a/chromium/cc/layers/picture_image_layer_unittest.cc +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright 2015 The Chromium 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 "cc/layers/picture_image_layer.h" - -#include "cc/animation/animation_host.h" -#include "cc/paint/paint_image_builder.h" -#include "cc/test/fake_layer_tree_host.h" -#include "cc/test/skia_common.h" -#include "cc/test/test_task_graph_runner.h" -#include "testing/gtest/include/gtest/gtest.h" -#include "third_party/skia/include/core/SkCanvas.h" -#include "third_party/skia/include/core/SkColor.h" -#include "third_party/skia/include/core/SkImage.h" -#include "third_party/skia/include/core/SkSurface.h" - -namespace cc { -namespace { - -TEST(PictureImageLayerTest, PaintContentsToDisplayList) { - scoped_refptr<PictureImageLayer> layer = PictureImageLayer::Create(); - FakeLayerTreeHostClient client; - TestTaskGraphRunner task_graph_runner; - auto animation_host = AnimationHost::CreateForTesting(ThreadInstance::MAIN); - std::unique_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create( - &client, &task_graph_runner, animation_host.get()); - layer->SetLayerTreeHost(host.get()); - gfx::Rect layer_rect(200, 200); - - unsigned char image_pixels[4 * 200 * 200] = {0}; - SkImageInfo info = - SkImageInfo::MakeN32Premul(layer_rect.width(), layer_rect.height()); - sk_sp<SkSurface> image_surface = - SkSurface::MakeRasterDirect(info, image_pixels, info.minRowBytes()); - SkCanvas* image_canvas = image_surface->getCanvas(); - image_canvas->clear(SK_ColorRED); - SkPaint blue_paint; - blue_paint.setColor(SK_ColorBLUE); - image_canvas->drawRect(SkRect::MakeWH(100, 100), blue_paint); - image_canvas->drawRect(SkRect::MakeLTRB(100, 100, 200, 200), blue_paint); - - layer->SetImage(PaintImageBuilder::WithDefault() - .set_id(PaintImage::GetNextId()) - .set_image(image_surface->makeImageSnapshot(), - PaintImage::GetNextContentId()) - .TakePaintImage(), - SkMatrix::I(), false); - layer->SetBounds(gfx::Size(layer_rect.width(), layer_rect.height())); - - scoped_refptr<DisplayItemList> display_list = - layer->PaintContentsToDisplayList( - ContentLayerClient::PAINTING_BEHAVIOR_NORMAL); - unsigned char actual_pixels[4 * 200 * 200] = {0}; - DrawDisplayList(actual_pixels, layer_rect, display_list); - - EXPECT_EQ(0, memcmp(actual_pixels, image_pixels, 4 * 200 * 200)); - - layer->SetLayerTreeHost(nullptr); -} - -} // namespace -} // namespace cc diff --git a/chromium/cc/layers/picture_layer.cc b/chromium/cc/layers/picture_layer.cc index b7244152c31..0baee75a961 100644 --- a/chromium/cc/layers/picture_layer.cc +++ b/chromium/cc/layers/picture_layer.cc @@ -137,9 +137,17 @@ bool PictureLayer::Update() { &last_updated_invalidation_, layer_size, recorded_viewport); if (updated) { - picture_layer_inputs_.display_list = - picture_layer_inputs_.client->PaintContentsToDisplayList( - ContentLayerClient::PAINTING_BEHAVIOR_NORMAL); + { + auto old_display_list = std::move(picture_layer_inputs_.display_list); + picture_layer_inputs_.display_list = + picture_layer_inputs_.client->PaintContentsToDisplayList( + ContentLayerClient::PAINTING_BEHAVIOR_NORMAL); + if (old_display_list && + picture_layer_inputs_.display_list + ->NeedsAdditionalInvalidationForLCDText(*old_display_list)) { + last_updated_invalidation_ = gfx::Rect(bounds()); + } + } // Clear out previous directly composited image state - if the layer // qualifies we'll set up the state below. @@ -282,14 +290,6 @@ bool PictureLayer::ShouldUseTransformedRasterization() const { if (!picture_layer_inputs_.transformed_rasterization_allowed) return false; - // Background color overfill is undesirable with transformed rasterization. - // However, without background overfill, the tiles will be non-opaque on - // external edges, and layer opaque region can't be computed in layer space - // due to rounding under extreme scaling. This defeats many opaque layer - // optimization. Prefer optimization over quality for this particular case. - if (contents_opaque()) - return false; - const TransformTree& transform_tree = layer_tree_host()->property_trees()->transform_tree; DCHECK(!transform_tree.needs_update()); diff --git a/chromium/cc/layers/picture_layer_impl.cc b/chromium/cc/layers/picture_layer_impl.cc index 00e845e2b3f..0f030bd4ff3 100644 --- a/chromium/cc/layers/picture_layer_impl.cc +++ b/chromium/cc/layers/picture_layer_impl.cc @@ -258,12 +258,16 @@ void PictureLayerImpl::AppendQuads(viz::RenderPass* render_pass, // |PictureLayerTiling::EnclosingContentsRectFromLayer()| will // create a tiling that, when scaled by |max_contents_scale| above, is // larger than the layer bounds by a fraction of a pixel. - gfx::Rect clip_rect = draw_properties().drawable_content_rect; + gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect( + draw_properties().target_space_transform, gfx::Rect(bounds())); + if (is_clipped()) + bounds_in_target_space.Intersect(draw_properties().clip_rect); + if (shared_quad_state->is_clipped) - clip_rect.Intersect(shared_quad_state->clip_rect); + bounds_in_target_space.Intersect(shared_quad_state->clip_rect); shared_quad_state->is_clipped = true; - shared_quad_state->clip_rect = clip_rect; + shared_quad_state->clip_rect = bounds_in_target_space; #if DCHECK_IS_ON() // Validate that the tile and bounds size are always within one pixel. @@ -836,22 +840,24 @@ LCDTextDisallowedReason PictureLayerImpl::ComputeLCDTextDisallowedReason() return LCDTextDisallowedReason::kNone; if (!layer_tree_impl()->settings().can_use_lcd_text) return LCDTextDisallowedReason::kSetting; - if (!contents_opaque()) { + if (!contents_opaque_for_text()) { if (SkColorGetA(background_color()) != SK_AlphaOPAQUE) return LCDTextDisallowedReason::kBackgroundColorNotOpaque; return LCDTextDisallowedReason::kContentsNotOpaque; } - if (!GetTransformTree() - .Node(transform_tree_index()) - ->node_and_ancestors_have_only_integer_translation) - return LCDTextDisallowedReason::kNonIntegralTranslation; - if (static_cast<int>(offset_to_transform_parent().x()) != - offset_to_transform_parent().x()) - return LCDTextDisallowedReason::kNonIntegralXOffset; - if (static_cast<int>(offset_to_transform_parent().y()) != - offset_to_transform_parent().y()) - return LCDTextDisallowedReason::kNonIntegralYOffset; + if (!use_transformed_rasterization_) { + if (!GetTransformTree() + .Node(transform_tree_index()) + ->node_and_ancestors_have_only_integer_translation) + return LCDTextDisallowedReason::kNonIntegralTranslation; + if (static_cast<int>(offset_to_transform_parent().x()) != + offset_to_transform_parent().x()) + return LCDTextDisallowedReason::kNonIntegralXOffset; + if (static_cast<int>(offset_to_transform_parent().y()) != + offset_to_transform_parent().y()) + return LCDTextDisallowedReason::kNonIntegralYOffset; + } if (has_will_change_transform_hint()) return LCDTextDisallowedReason::kWillChangeTransform; @@ -1066,6 +1072,11 @@ void PictureLayerImpl::SetNearestNeighbor(bool nearest_neighbor) { } void PictureLayerImpl::SetUseTransformedRasterization(bool use) { + // With transformed rasterization, the pixels along the edge of the layer may + // become translucent, so clear contents_opaque. + if (use) + SetContentsOpaque(false); + if (use_transformed_rasterization_ == use) return; @@ -1561,6 +1572,8 @@ gfx::Vector2dF PictureLayerImpl::CalculateRasterTranslation( if (!use_transformed_rasterization_) return gfx::Vector2dF(); + DCHECK(!contents_opaque()); + gfx::Transform draw_transform = DrawTransform(); // TODO(enne): for performance reasons, we should only have a raster // translation when the screen space transform is not animating. We try to diff --git a/chromium/cc/layers/picture_layer_impl_unittest.cc b/chromium/cc/layers/picture_layer_impl_unittest.cc index 25fff7cb2ae..38609980105 100644 --- a/chromium/cc/layers/picture_layer_impl_unittest.cc +++ b/chromium/cc/layers/picture_layer_impl_unittest.cc @@ -5981,5 +5981,33 @@ TEST_F(LegacySWPictureLayerImplTest, NoTilingsUsesScaleOne) { EXPECT_RECT_EQ(gfx::Rect(1000, 10000), shared_quad_state->quad_layer_rect); EXPECT_TRUE(shared_quad_state->quad_to_target_transform.IsIdentity()); } + +TEST_F(LegacySWPictureLayerImplTest, + TransformedRasterizationAndContentsOpaqueAndLCDText) { + SetupDefaultTreesWithInvalidation(gfx::Size(200, 200), Region()); + + pending_layer()->SetBackgroundColor(SK_ColorWHITE); + pending_layer()->SetContentsOpaque(true); + pending_layer()->SetOffsetToTransformParent(gfx::Vector2dF(0.2, 0.3)); + EXPECT_TRUE(pending_layer()->contents_opaque()); + EXPECT_TRUE(pending_layer()->contents_opaque_for_text()); + EXPECT_EQ(LCDTextDisallowedReason::kNonIntegralXOffset, + pending_layer()->ComputeLCDTextDisallowedReasonForTesting()); + + pending_layer()->SetUseTransformedRasterization(true); + EXPECT_FALSE(pending_layer()->contents_opaque()); + EXPECT_FALSE(pending_layer()->contents_opaque_for_text()); + EXPECT_EQ(LCDTextDisallowedReason::kContentsNotOpaque, + pending_layer()->ComputeLCDTextDisallowedReasonForTesting()); + + // Simulate another push from main-thread with the same values. + pending_layer()->SetContentsOpaque(true); + pending_layer()->SetUseTransformedRasterization(true); + EXPECT_FALSE(pending_layer()->contents_opaque()); + EXPECT_FALSE(pending_layer()->contents_opaque_for_text()); + EXPECT_EQ(LCDTextDisallowedReason::kContentsNotOpaque, + pending_layer()->ComputeLCDTextDisallowedReasonForTesting()); +} + } // namespace } // namespace cc diff --git a/chromium/cc/layers/render_surface_impl.cc b/chromium/cc/layers/render_surface_impl.cc index 3d60067a835..f3cd766fdd5 100644 --- a/chromium/cc/layers/render_surface_impl.cc +++ b/chromium/cc/layers/render_surface_impl.cc @@ -134,10 +134,6 @@ const FilterOperations& RenderSurfaceImpl::Filters() const { return OwningEffectNode()->filters; } -gfx::PointF RenderSurfaceImpl::FiltersOrigin() const { - return OwningEffectNode()->filters_origin; -} - gfx::Transform RenderSurfaceImpl::SurfaceScale() const { gfx::Transform surface_scale; surface_scale.Scale(OwningEffectNode()->surface_contents_scale.x(), @@ -303,7 +299,7 @@ void RenderSurfaceImpl::AccumulateContentRectFromContributingLayer( if (render_target() == this) return; - accumulated_content_rect_.Union(layer->drawable_content_rect()); + accumulated_content_rect_.Union(layer->visible_drawable_content_rect()); } void RenderSurfaceImpl::AccumulateContentRectFromContributingRenderSurface( @@ -456,7 +452,7 @@ void RenderSurfaceImpl::AppendQuads(DrawMode draw_mode, auto* quad = render_pass->CreateAndAppendDrawQuad<viz::RenderPassDrawQuad>(); quad->SetAll(shared_quad_state, content_rect(), unoccluded_content_rect, /*needs_blending=*/true, id(), mask_resource_id, mask_uv_rect, - mask_texture_size, surface_contents_scale, FiltersOrigin(), + mask_texture_size, surface_contents_scale, gfx::PointF(), tex_coord_rect, !layer_tree_impl_->settings().enable_edge_anti_aliasing, OwningEffectNode()->backdrop_filter_quality, diff --git a/chromium/cc/layers/render_surface_impl.h b/chromium/cc/layers/render_surface_impl.h index 72587093ba7..fac0274a79d 100644 --- a/chromium/cc/layers/render_surface_impl.h +++ b/chromium/cc/layers/render_surface_impl.h @@ -168,7 +168,6 @@ class CC_EXPORT RenderSurfaceImpl { const FilterOperations& BackdropFilters() const; base::Optional<gfx::RRectF> BackdropFilterBounds() const; LayerImpl* BackdropMaskLayer() const; - gfx::PointF FiltersOrigin() const; gfx::Transform SurfaceScale() const; bool TrilinearFiltering() const; diff --git a/chromium/cc/layers/scrollbar_layer_impl_base.cc b/chromium/cc/layers/scrollbar_layer_impl_base.cc index 2d9e885c030..787f339fb49 100644 --- a/chromium/cc/layers/scrollbar_layer_impl_base.cc +++ b/chromium/cc/layers/scrollbar_layer_impl_base.cc @@ -291,6 +291,10 @@ bool ScrollbarLayerImplBase::SupportsDragSnapBack() const { return false; } +bool ScrollbarLayerImplBase::JumpOnTrackClick() const { + return false; +} + gfx::Rect ScrollbarLayerImplBase::BackButtonRect() const { return gfx::Rect(0, 0); } diff --git a/chromium/cc/layers/scrollbar_layer_impl_base.h b/chromium/cc/layers/scrollbar_layer_impl_base.h index 3b508f3c17a..a887ab47ed2 100644 --- a/chromium/cc/layers/scrollbar_layer_impl_base.h +++ b/chromium/cc/layers/scrollbar_layer_impl_base.h @@ -72,6 +72,7 @@ class CC_EXPORT ScrollbarLayerImplBase : public LayerImpl { virtual gfx::Rect BackTrackRect() const; virtual gfx::Rect ForwardTrackRect() const; virtual bool SupportsDragSnapBack() const; + virtual bool JumpOnTrackClick() const; virtual ScrollbarPart IdentifyScrollbarPart( const gfx::PointF position_in_widget) const; // Only PaintedOverlayScrollbar(Aura Overlay Scrollbar) need to know diff --git a/chromium/cc/layers/solid_color_layer_impl.cc b/chromium/cc/layers/solid_color_layer_impl.cc index 48c728cfde6..242f76415f9 100644 --- a/chromium/cc/layers/solid_color_layer_impl.cc +++ b/chromium/cc/layers/solid_color_layer_impl.cc @@ -53,6 +53,9 @@ void SolidColorLayerImpl::AppendSolidQuads( gfx::Rect visible_quad_rect = occlusion_in_layer_space.GetUnoccludedContentRect(visible_layer_rect); + if (visible_quad_rect.IsEmpty()) + return; + auto* quad = render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>(); quad->SetNew(shared_quad_state, visible_layer_rect, visible_quad_rect, color, force_anti_aliasing_off); diff --git a/chromium/cc/layers/texture_layer_impl.cc b/chromium/cc/layers/texture_layer_impl.cc index 5b4229280eb..544676a563b 100644 --- a/chromium/cc/layers/texture_layer_impl.cc +++ b/chromium/cc/layers/texture_layer_impl.cc @@ -9,6 +9,7 @@ #include <vector> +#include "base/logging.h" #include "base/strings/stringprintf.h" #include "cc/trees/layer_tree_frame_sink.h" #include "cc/trees/layer_tree_impl.h" diff --git a/chromium/cc/layers/video_layer_impl_unittest.cc b/chromium/cc/layers/video_layer_impl_unittest.cc index 8a22f392e56..06197477989 100644 --- a/chromium/cc/layers/video_layer_impl_unittest.cc +++ b/chromium/cc/layers/video_layer_impl_unittest.cc @@ -395,8 +395,7 @@ TEST(VideoLayerImplTest, NativeYUVFrameGeneratesYUVQuad) { gfx::Size(10, 10), gfx::Rect(10, 10), gfx::Size(10, 10), base::TimeDelta()); ASSERT_TRUE(video_frame); - video_frame->metadata()->SetBoolean(media::VideoFrameMetadata::ALLOW_OVERLAY, - true); + video_frame->metadata()->allow_overlay = true; FakeVideoFrameProvider provider; provider.set_frame(video_frame); @@ -439,8 +438,7 @@ TEST(VideoLayerImplTest, NativeARGBFrameGeneratesTextureQuad) { media::PIXEL_FORMAT_ARGB, mailbox_holders, base::DoNothing(), resource_size, gfx::Rect(10, 10), resource_size, base::TimeDelta()); ASSERT_TRUE(video_frame); - video_frame->metadata()->SetBoolean(media::VideoFrameMetadata::ALLOW_OVERLAY, - true); + video_frame->metadata()->allow_overlay = true; FakeVideoFrameProvider provider; provider.set_frame(video_frame); diff --git a/chromium/cc/metrics/compositor_frame_reporter.cc b/chromium/cc/metrics/compositor_frame_reporter.cc index 13c15d9b1dd..c5b037edf4d 100644 --- a/chromium/cc/metrics/compositor_frame_reporter.cc +++ b/chromium/cc/metrics/compositor_frame_reporter.cc @@ -4,6 +4,7 @@ #include "cc/metrics/compositor_frame_reporter.h" +#include <algorithm> #include <memory> #include <string> #include <utility> @@ -11,10 +12,14 @@ #include "base/metrics/histogram_macros.h" #include "base/stl_util.h" #include "base/strings/strcat.h" +#include "base/time/time.h" #include "base/trace_event/trace_event.h" #include "cc/base/rolling_time_delta_history.h" +#include "cc/metrics/dropped_frame_counter.h" #include "cc/metrics/frame_sequence_tracker.h" #include "cc/metrics/latency_ukm_reporter.h" +#include "services/tracing/public/cpp/perfetto/macros.h" +#include "third_party/perfetto/protos/perfetto/trace/track_event/chrome_frame_reporter.pbzero.h" #include "ui/events/types/event_type.h" namespace cc { @@ -42,7 +47,8 @@ constexpr int kFrameSequenceTrackerTypeCount = static_cast<int>(FrameSequenceTrackerType::kMaxType) + 1; // Names for the viz breakdowns that are shown in trace as substages under -// PipelineReporter -> SubmitCompositorFrameToPresentationCompositorFrame +// PipelineReporter -> SubmitCompositorFrameToPresentationCompositorFrame or +// EventLatency -> SubmitCompositorFrameToPresentationCompositorFrame. constexpr const char* GetVizBreakdownName(VizBreakdown stage) { switch (stage) { case VizBreakdown::kSubmitToReceiveCompositorFrame: @@ -55,6 +61,14 @@ constexpr const char* GetVizBreakdownName(VizBreakdown stage) { return "Swap"; case VizBreakdown::kSwapEndToPresentationCompositorFrame: return "SwapEndToPresentationCompositorFrame"; + case VizBreakdown::kSwapStartToBufferAvailable: + return "SwapStartToBufferAvailable"; + case VizBreakdown::kBufferAvailableToBufferReady: + return "BufferAvailableToBufferReady"; + case VizBreakdown::kBufferReadyToLatch: + return "BufferReadyToLatch"; + case VizBreakdown::kLatchToSwapEnd: + return "LatchToSwapEnd"; case VizBreakdown::kBreakdownCount: NOTREACHED(); return ""; @@ -165,9 +179,9 @@ constexpr int kCompositorLatencyHistogramMax = 350000; constexpr int kCompositorLatencyHistogramBucketCount = 50; constexpr int kEventLatencyEventTypeCount = - static_cast<int>(ui::EventType::ET_LAST); + static_cast<int>(EventMetrics::EventType::kMaxValue) + 1; constexpr int kEventLatencyScrollTypeCount = - static_cast<int>(ui::ScrollInputType::kMaxValue) + 1; + static_cast<int>(EventMetrics::ScrollType::kMaxValue) + 1; constexpr int kMaxEventLatencyHistogramBaseIndex = kEventLatencyEventTypeCount * kEventLatencyScrollTypeCount; constexpr int kMaxEventLatencyHistogramIndex = @@ -203,37 +217,81 @@ std::string GetCompositorLatencyHistogramName( std::string GetEventLatencyHistogramBaseName( const EventMetrics& event_metrics) { - const bool is_scroll = event_metrics.scroll_input_type().has_value(); + const bool is_scroll = event_metrics.scroll_type().has_value(); return base::StrCat( {"EventLatency.", event_metrics.GetTypeName(), is_scroll ? "." : nullptr, is_scroll ? event_metrics.GetScrollTypeName() : nullptr}); } +base::TimeTicks ComputeSafeDeadlineForFrame(const viz::BeginFrameArgs& args) { + return args.frame_time + (args.interval * 1.5); +} + +void ReportOffsetBetweenDeadlineAndPresentationTime( + const viz::BeginFrameArgs& args, + base::TimeTicks presentation_time) { + const base::TimeTicks strict_deadline = args.frame_time + args.interval; + const base::TimeDelta offset = presentation_time - strict_deadline; + // |strict_deadline| and |presentation_time| should normally be pretty close. + // Measure how close they are. + UMA_HISTOGRAM_CUSTOM_TIMES( + "CompositorLatency.Diagnostic.PresentationTimeDeltaFromDeadline", offset, + base::TimeDelta::FromMilliseconds(1), + base::TimeDelta::FromMilliseconds(32), /*bucket_count=*/16); +} + +#define REPORT_VIZ_TRACE_EVENT(start_time, end_time, index, trace_func) \ + if (start_time <= end_time) { \ + const char* substage_name = \ + GetVizBreakdownName(static_cast<VizBreakdown>(index)); \ + trace_func(start_time, end_time, substage_name); \ + } + +#define REPORT_VIZ_BREAKDOWN_TRACES(trace_func) \ + size_t start_to_buffer_available = \ + static_cast<size_t>(VizBreakdown::kSwapStartToBufferAvailable); \ + bool has_ready_timings = !!viz_breakdown_list_[start_to_buffer_available]; \ + for (size_t i = 0; i < start_to_buffer_available; i++) { \ + if (!viz_breakdown_list_[i]) \ + break; \ + \ + if (i == static_cast<size_t>(VizBreakdown::kSwapStartToSwapEnd) && \ + has_ready_timings) { \ + size_t latch_to_swap_end = \ + static_cast<size_t>(VizBreakdown::kLatchToSwapEnd); \ + for (size_t j = start_to_buffer_available; j <= latch_to_swap_end; \ + j++) { \ + REPORT_VIZ_TRACE_EVENT(viz_breakdown_list_[j]->first, \ + viz_breakdown_list_[j]->second, j, trace_func); \ + } \ + } else { \ + REPORT_VIZ_TRACE_EVENT(viz_breakdown_list_[i]->first, \ + viz_breakdown_list_[i]->second, i, trace_func); \ + } \ + } + } // namespace CompositorFrameReporter::CompositorFrameReporter( const ActiveTrackers& active_trackers, - const viz::BeginFrameId& id, - const base::TimeTicks frame_deadline, + const viz::BeginFrameArgs& args, LatencyUkmReporter* latency_ukm_reporter, bool should_report_metrics) - : frame_id_(id), - should_report_metrics_(should_report_metrics), + : should_report_metrics_(should_report_metrics), + args_(args), active_trackers_(active_trackers), - latency_ukm_reporter_(latency_ukm_reporter), - frame_deadline_(frame_deadline) {} + latency_ukm_reporter_(latency_ukm_reporter) {} std::unique_ptr<CompositorFrameReporter> CompositorFrameReporter::CopyReporterAtBeginImplStage() const { if (stage_history_.empty() || stage_history_.front().stage_type != StageType::kBeginImplFrameToSendBeginMainFrame || - !did_finish_impl_frame()) { + (!did_finish_impl_frame() && !did_not_produce_frame_time_.has_value())) { return nullptr; } auto new_reporter = std::make_unique<CompositorFrameReporter>( - active_trackers_, frame_id_, frame_deadline_, latency_ukm_reporter_, - should_report_metrics_); + active_trackers_, args_, latency_ukm_reporter_, should_report_metrics_); new_reporter->did_finish_impl_frame_ = did_finish_impl_frame_; new_reporter->impl_frame_finish_time_ = impl_frame_finish_time_; new_reporter->main_frame_abort_time_ = main_frame_abort_time_; @@ -241,6 +299,7 @@ CompositorFrameReporter::CopyReporterAtBeginImplStage() const { StageType::kBeginImplFrameToSendBeginMainFrame; new_reporter->current_stage_.start_time = stage_history_.front().start_time; new_reporter->set_tick_clock(tick_clock_); + new_reporter->SetDroppedFrameCounter(dropped_frame_counter_); return new_reporter; } @@ -349,36 +408,33 @@ void CompositorFrameReporter::TerminateReporter() { PopulateVizBreakdownList(); DCHECK_EQ(current_stage_.start_time, base::TimeTicks()); - const char* termination_status_str = nullptr; switch (frame_termination_status_) { case FrameTerminationStatus::kPresentedFrame: EnableReportType(FrameReportType::kNonDroppedFrame); - termination_status_str = "presented_frame"; - if (frame_deadline_ < frame_termination_time_) + ReportOffsetBetweenDeadlineAndPresentationTime(args_, + frame_termination_time_); + if (ComputeSafeDeadlineForFrame(args_) < frame_termination_time_) EnableReportType(FrameReportType::kMissedDeadlineFrame); break; case FrameTerminationStatus::kDidNotPresentFrame: EnableReportType(FrameReportType::kDroppedFrame); - termination_status_str = "did_not_present_frame"; break; case FrameTerminationStatus::kReplacedByNewReporter: EnableReportType(FrameReportType::kDroppedFrame); - termination_status_str = "replaced_by_new_reporter_at_same_stage"; break; case FrameTerminationStatus::kDidNotProduceFrame: - termination_status_str = "did_not_produce_frame"; if (!frame_skip_reason_.has_value() || frame_skip_reason() != FrameSkippedReason::kNoDamage) { EnableReportType(FrameReportType::kDroppedFrame); - termination_status_str = "dropped_frame"; } break; case FrameTerminationStatus::kUnknown: - termination_status_str = "terminated_before_ending"; break; } - ReportAllTraceEvents(termination_status_str); + ReportCompositorLatencyTraceEvents(); + if (TestReportType(FrameReportType::kNonDroppedFrame)) + ReportEventLatencyTraceEvents(); // Only report compositor latency histograms if the frame was produced. if (should_report_metrics_ && report_types_.any()) { @@ -394,6 +450,17 @@ void CompositorFrameReporter::TerminateReporter() { if (TestReportType(FrameReportType::kNonDroppedFrame)) ReportEventLatencyHistograms(); } + + if (dropped_frame_counter_) { + if (TestReportType(FrameReportType::kDroppedFrame)) { + dropped_frame_counter_->AddDroppedFrame(); + } else { + if (has_partial_update_) + dropped_frame_counter_->AddPartialFrame(); + else + dropped_frame_counter_->AddGoodFrame(); + } + } } void CompositorFrameReporter::EndCurrentStage(base::TimeTicks end_time) { @@ -421,8 +488,8 @@ void CompositorFrameReporter::ReportCompositorLatencyHistograms() const { FrameReportType report_type = static_cast<FrameReportType>(type); UMA_HISTOGRAM_ENUMERATION("CompositorLatency.Type", report_type); if (latency_ukm_reporter_) { - latency_ukm_reporter_->ReportLatencyUkm(report_type, stage_history_, - active_trackers_, viz_breakdown_); + latency_ukm_reporter_->ReportCompositorLatencyUkm( + report_type, stage_history_, active_trackers_, viz_breakdown_); } for (size_t fst_type = 0; fst_type < active_trackers_.size(); ++fst_type) { if (!active_trackers_.test(fst_type)) { @@ -510,9 +577,11 @@ void CompositorFrameReporter::ReportCompositorLatencyVizBreakdowns( #endif break; } + const base::TimeTicks start_time = viz_breakdown_list_[i]->first; + const base::TimeTicks end_time = viz_breakdown_list_[i]->second; ReportCompositorLatencyHistogram(frame_sequence_tracker_type, kVizBreakdownInitialIndex + i, - *viz_breakdown_list_[i]); + end_time - start_time); } } @@ -561,8 +630,8 @@ void CompositorFrameReporter::ReportEventLatencyHistograms() const { GetEventLatencyHistogramBaseName(event_metrics); const int event_type_index = static_cast<int>(event_metrics.type()); const int scroll_type_index = - event_metrics.scroll_input_type() - ? static_cast<int>(*event_metrics.scroll_input_type()) + event_metrics.scroll_type() + ? static_cast<int>(*event_metrics.scroll_type()) : 0; const int histogram_base_index = event_type_index * kEventLatencyScrollTypeCount + scroll_type_index; @@ -570,8 +639,7 @@ void CompositorFrameReporter::ReportEventLatencyHistograms() const { // For scroll events, report total latency up to gpu-swap-end. This is // useful in comparing new EventLatency metrics with LatencyInfo-based // scroll event latency metrics. - if (event_metrics.scroll_input_type() && - !viz_breakdown_.swap_timings.is_null()) { + if (event_metrics.scroll_type() && !viz_breakdown_.swap_timings.is_null()) { const base::TimeDelta swap_end_latency = viz_breakdown_.swap_timings.swap_end - event_metrics.time_stamp(); const std::string swap_end_histogram_name = @@ -586,57 +654,51 @@ void CompositorFrameReporter::ReportEventLatencyHistograms() const { base::HistogramBase::kUmaTargetedHistogramFlag)); } - const auto trace_id = TRACE_ID_LOCAL(&event_metrics); - TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( - "cc,input", "EventLatency", trace_id, event_metrics.time_stamp(), - "event", event_metrics.GetTypeName()); - // It is possible for an event to arrive in the compositor in the middle of // a frame (e.g. the browser received the event *after* renderer received a // begin-impl, and the event reached the compositor before that frame // ended). To handle such cases, find the first stage that happens after the // event's arrival in the browser. - size_t index = 0; - for (; index < stage_history_.size(); ++index) { - const auto& stage = stage_history_[index]; - if (stage.start_time > event_metrics.time_stamp()) { - const char stage_type_name[] = "BrowserToRendererCompositor"; - - const base::TimeDelta latency = - stage.start_time - event_metrics.time_stamp(); - const std::string histogram_name = - base::StrCat({histogram_base_name, ".", stage_type_name}); - STATIC_HISTOGRAM_POINTER_GROUP( - histogram_name, histogram_base_index, - kMaxEventLatencyHistogramBaseIndex, - AddTimeMicrosecondsGranularity(latency), - base::Histogram::FactoryGet( - histogram_name, kEventLatencyHistogramMin, - kEventLatencyHistogramMax, kEventLatencyHistogramBucketCount, - base::HistogramBase::kUmaTargetedHistogramFlag)); - - TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( - "cc,input", stage_type_name, trace_id, event_metrics.time_stamp()); - TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( - "cc,input", stage_type_name, trace_id, stage.start_time); - break; - } - } + auto stage_it = + std::find_if(stage_history_.begin(), stage_history_.end(), + [&event_metrics](const StageData& stage) { + return stage.start_time > event_metrics.time_stamp(); + }); + // TODO(crbug.com/1079116): Ideally, at least the start time of + // SubmitCompositorFrameToPresentationCompositorFrame stage should be + // greater than the event time stamp, but apparently, this is not always the + // case (see crbug.com/1093698). For now, skip to the next event in such + // cases. Hopefully, the work to reduce discrepancies between the new + // EventLatency and the old Event.Latency metrics would fix this issue. If + // not, we need to reconsider investigating this issue. + if (stage_it == stage_history_.end()) + continue; - for (; index < stage_history_.size(); ++index) { - const auto& stage = stage_history_[index]; + const base::TimeDelta b2r_latency = + stage_it->start_time - event_metrics.time_stamp(); + const std::string b2r_histogram_name = + histogram_base_name + ".BrowserToRendererCompositor"; + STATIC_HISTOGRAM_POINTER_GROUP( + b2r_histogram_name, histogram_base_index, + kMaxEventLatencyHistogramBaseIndex, + AddTimeMicrosecondsGranularity(b2r_latency), + base::Histogram::FactoryGet( + b2r_histogram_name, kEventLatencyHistogramMin, + kEventLatencyHistogramMax, kEventLatencyHistogramBucketCount, + base::HistogramBase::kUmaTargetedHistogramFlag)); + for (; stage_it != stage_history_.end(); ++stage_it) { // Total latency is calculated since the event timestamp. const base::TimeTicks start_time = - stage.stage_type == StageType::kTotalLatency + stage_it->stage_type == StageType::kTotalLatency ? event_metrics.time_stamp() - : stage.start_time; - const base::TimeDelta latency = stage.end_time - start_time; - const int stage_type_index = static_cast<int>(stage.stage_type); + : stage_it->start_time; + const base::TimeDelta latency = stage_it->end_time - start_time; + const int stage_type_index = static_cast<int>(stage_it->stage_type); ReportEventLatencyHistogram(histogram_base_index, histogram_base_name, stage_type_index, latency); - switch (stage.stage_type) { + switch (stage_it->stage_type) { case StageType::kSendBeginMainFrameToCommit: ReportEventLatencyBlinkBreakdowns(histogram_base_index, histogram_base_name); @@ -648,18 +710,12 @@ void CompositorFrameReporter::ReportEventLatencyHistograms() const { default: break; } - - if (stage.stage_type != StageType::kTotalLatency) { - TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( - "cc,input", GetStageName(stage_type_index), trace_id, - stage.start_time); - TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( - "cc,input", GetStageName(stage_type_index), trace_id, - stage.end_time); - } } - TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( - "cc,input", "EventLatency", trace_id, frame_termination_time_); + } + + if (latency_ukm_reporter_) { + latency_ukm_reporter_->ReportEventLatencyUkm( + events_metrics_, stage_history_, viz_breakdown_); } } @@ -685,9 +741,11 @@ void CompositorFrameReporter::ReportEventLatencyVizBreakdowns( #endif break; } + const base::TimeTicks start_time = viz_breakdown_list_[i]->first; + const base::TimeTicks end_time = viz_breakdown_list_[i]->second; ReportEventLatencyHistogram(histogram_base_index, histogram_base_name, kVizBreakdownInitialIndex + i, - *viz_breakdown_list_[i]); + end_time - start_time); } } @@ -710,32 +768,31 @@ void CompositorFrameReporter::ReportEventLatencyHistogram( base::HistogramBase::kUmaTargetedHistogramFlag)); } -void CompositorFrameReporter::ReportVizBreakdownTrace( - VizBreakdown substage, - const base::TimeTicks start_time, - const base::TimeTicks end_time) const { - // Do not report events with negative time span. - if (end_time < start_time) - return; - - const char* stage_name = GetVizBreakdownName(substage); - TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( - "cc,benchmark", stage_name, TRACE_ID_LOCAL(this), start_time); - - TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( - "cc,benchmark", stage_name, TRACE_ID_LOCAL(this), end_time); -} - -void CompositorFrameReporter::ReportAllTraceEvents( - const char* termination_status_str) const { +void CompositorFrameReporter::ReportCompositorLatencyTraceEvents() const { if (stage_history_.empty()) return; - const auto trace_id = TRACE_ID_LOCAL(this); - const auto& startstage = stage_history_.front(); - TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( - "cc,benchmark", "PipelineReporter", trace_id, startstage.start_time, - "frame_id", frame_id_.ToString()); + const auto trace_track = perfetto::Track(reinterpret_cast<uint64_t>(this)); + TRACE_EVENT_BEGIN( + "cc,benchmark", "PipelineReporter", trace_track, + stage_history_.front().start_time, [&](perfetto::EventContext context) { + using perfetto::protos::pbzero::ChromeFrameReporter; + bool frame_dropped = TestReportType(FrameReportType::kDroppedFrame); + ChromeFrameReporter::State state; + if (frame_dropped) { + state = ChromeFrameReporter::STATE_DROPPED; + } else if (frame_termination_status_ == + FrameTerminationStatus::kDidNotProduceFrame) { + state = ChromeFrameReporter::STATE_NO_UPDATE_DESIRED; + } else { + state = ChromeFrameReporter::STATE_PRESENTED_ALL; + } + auto* reporter = context.event()->set_chrome_frame_reporter(); + reporter->set_state(state); + reporter->set_frame_source(args_.frame_id.source_id); + reporter->set_frame_sequence(args_.frame_id.sequence_number); + // TODO(crbug.com/1086974): Set 'drop reason' if applicable. + }); // The trace-viewer cannot seem to handle a single child-event that has the // same start/end timestamps as the parent-event. So avoid adding the @@ -750,50 +807,89 @@ void CompositorFrameReporter::ReportAllTraceEvents( DCHECK_GE(stage.end_time, stage.start_time); if (stage.start_time == stage.end_time) continue; - const char* name = GetStageName(stage_type_index); + const char* stage_name = GetStageName(stage_type_index); + TRACE_EVENT_BEGIN("cc,benchmark", stage_name, trace_track, + stage.start_time); + if (stage.stage_type == + StageType::kSubmitCompositorFrameToPresentationCompositorFrame) { + REPORT_VIZ_BREAKDOWN_TRACES([&](base::TimeTicks start_time, + base::TimeTicks end_time, + const char* substage_name) { + TRACE_EVENT_BEGIN("cc,benchmark", substage_name, trace_track, + start_time); + TRACE_EVENT_END("cc,benchmark", trace_track, end_time); + }); + } + TRACE_EVENT_END("cc,benchmark", trace_track, stage.end_time); + } + } + + TRACE_EVENT_END("cc,benchmark", trace_track, frame_termination_time_); +} + +void CompositorFrameReporter::ReportEventLatencyTraceEvents() const { + for (const EventMetrics& event_metrics : events_metrics_) { + const auto trace_id = TRACE_ID_LOCAL(&event_metrics); + TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( + "cc,input", "EventLatency", trace_id, event_metrics.time_stamp(), + "event", event_metrics.GetTypeName()); + + // Find the first stage that happens after the event's arrival in the + // browser. + auto stage_it = + std::find_if(stage_history_.begin(), stage_history_.end(), + [&event_metrics](const StageData& stage) { + return stage.start_time > event_metrics.time_stamp(); + }); + // TODO(crbug.com/1079116): Ideally, at least the start time of + // SubmitCompositorFrameToPresentationCompositorFrame stage should be + // greater than the event time stamp, but apparently, this is not always the + // case (see crbug.com/1093698). For now, skip to the next event in such + // cases. Hopefully, the work to reduce discrepancies between the new + // EventLatency and the old Event.Latency metrics would fix this issue. If + // not, we need to reconsider investigating this issue. + if (stage_it == stage_history_.end()) + continue; + + TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( + "cc,input", "BrowserToRendererCompositor", trace_id, + event_metrics.time_stamp()); + TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( + "cc,input", "BrowserToRendererCompositor", trace_id, + stage_it->start_time); + + for (; stage_it != stage_history_.end(); ++stage_it) { + const int stage_type_index = static_cast<int>(stage_it->stage_type); + CHECK_LT(stage_type_index, static_cast<int>(StageType::kStageTypeCount)); + CHECK_GE(stage_type_index, 0); + if (stage_it->start_time >= frame_termination_time_) + break; + DCHECK_GE(stage_it->end_time, stage_it->start_time); + if (stage_it->start_time == stage_it->end_time) + continue; + const char* stage_name = GetStageName(stage_type_index); + TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( - "cc,benchmark", name, trace_id, stage.start_time); + "cc,input", stage_name, trace_id, stage_it->start_time); - if (stage.stage_type == + if (stage_it->stage_type == StageType::kSubmitCompositorFrameToPresentationCompositorFrame) { - const struct { - VizBreakdown stage; - base::TimeTicks start_time; - base::TimeTicks end_time; - } sub_stages[] = { - {VizBreakdown::kSubmitToReceiveCompositorFrame, stage.start_time, - viz_breakdown_.received_compositor_frame_timestamp}, - {VizBreakdown::kReceivedCompositorFrameToStartDraw, - viz_breakdown_.received_compositor_frame_timestamp, - viz_breakdown_.draw_start_timestamp}, - {VizBreakdown::kStartDrawToSwapStart, - viz_breakdown_.draw_start_timestamp, - viz_breakdown_.swap_timings.swap_start}, - {VizBreakdown::kSwapStartToSwapEnd, - viz_breakdown_.swap_timings.swap_start, - viz_breakdown_.swap_timings.swap_end}, - {VizBreakdown::kSwapEndToPresentationCompositorFrame, - viz_breakdown_.swap_timings.swap_end, - viz_breakdown_.presentation_feedback.timestamp}}; - for (const auto& sub : sub_stages) { - if (sub.start_time.is_null() || sub.end_time.is_null()) - break; - ReportVizBreakdownTrace(sub.stage, sub.start_time, sub.end_time); - } + REPORT_VIZ_BREAKDOWN_TRACES([&](base::TimeTicks start_time, + base::TimeTicks end_time, + const char* substage_name) { + TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( + "cc,input", substage_name, trace_id, start_time); + TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( + "cc,input", substage_name, trace_id, end_time); + }); } - TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0("cc,benchmark", name, - trace_id, stage.end_time); + TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( + "cc,input", stage_name, trace_id, stage_it->end_time); } + TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( + "cc,input", "EventLatency", trace_id, frame_termination_time_); } - - const char* submission_status_str = - TestReportType(FrameReportType::kDroppedFrame) ? "dropped_frame" - : "non_dropped_frame"; - TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP2( - "cc,benchmark", "PipelineReporter", trace_id, frame_termination_time_, - "termination_status", termination_status_str, - "compositor_frame_submission_status", submission_status_str); } void CompositorFrameReporter::PopulateBlinkBreakdownList() { @@ -839,29 +935,47 @@ void CompositorFrameReporter::PopulateVizBreakdownList() { } viz_breakdown_list_[static_cast<int>( VizBreakdown::kSubmitToReceiveCompositorFrame)] = - viz_breakdown_.received_compositor_frame_timestamp - viz_start_time_; + std::make_pair(viz_start_time_, + viz_breakdown_.received_compositor_frame_timestamp); if (viz_breakdown_.draw_start_timestamp.is_null()) return; viz_breakdown_list_[static_cast<int>( VizBreakdown::kReceivedCompositorFrameToStartDraw)] = - viz_breakdown_.draw_start_timestamp - - viz_breakdown_.received_compositor_frame_timestamp; + std::make_pair(viz_breakdown_.received_compositor_frame_timestamp, + viz_breakdown_.draw_start_timestamp); if (viz_breakdown_.swap_timings.is_null()) return; viz_breakdown_list_[static_cast<int>(VizBreakdown::kStartDrawToSwapStart)] = - viz_breakdown_.swap_timings.swap_start - - viz_breakdown_.draw_start_timestamp; + std::make_pair(viz_breakdown_.draw_start_timestamp, + viz_breakdown_.swap_timings.swap_start); viz_breakdown_list_[static_cast<int>(VizBreakdown::kSwapStartToSwapEnd)] = - viz_breakdown_.swap_timings.swap_end - - viz_breakdown_.swap_timings.swap_start; + std::make_pair(viz_breakdown_.swap_timings.swap_start, + viz_breakdown_.swap_timings.swap_end); viz_breakdown_list_[static_cast<int>( VizBreakdown::kSwapEndToPresentationCompositorFrame)] = - viz_breakdown_.presentation_feedback.timestamp - - viz_breakdown_.swap_timings.swap_end; + std::make_pair(viz_breakdown_.swap_timings.swap_end, + viz_breakdown_.presentation_feedback.timestamp); + + if (viz_breakdown_.presentation_feedback.ready_timestamp.is_null()) + return; + viz_breakdown_list_[static_cast<int>( + VizBreakdown::kSwapStartToBufferAvailable)] = + std::make_pair(viz_breakdown_.swap_timings.swap_start, + viz_breakdown_.presentation_feedback.available_timestamp); + viz_breakdown_list_[static_cast<int>( + VizBreakdown::kBufferAvailableToBufferReady)] = + std::make_pair(viz_breakdown_.presentation_feedback.available_timestamp, + viz_breakdown_.presentation_feedback.ready_timestamp); + viz_breakdown_list_[static_cast<int>(VizBreakdown::kBufferReadyToLatch)] = + std::make_pair(viz_breakdown_.presentation_feedback.ready_timestamp, + viz_breakdown_.presentation_feedback.latch_timestamp); + viz_breakdown_list_[static_cast<int>(VizBreakdown::kLatchToSwapEnd)] = + std::make_pair(viz_breakdown_.presentation_feedback.latch_timestamp, + viz_breakdown_.swap_timings.swap_end); } base::TimeDelta CompositorFrameReporter::SumOfStageHistory() const { diff --git a/chromium/cc/metrics/compositor_frame_reporter.h b/chromium/cc/metrics/compositor_frame_reporter.h index 9cae550ba76..2ff3b986489 100644 --- a/chromium/cc/metrics/compositor_frame_reporter.h +++ b/chromium/cc/metrics/compositor_frame_reporter.h @@ -7,6 +7,7 @@ #include <bitset> #include <memory> +#include <utility> #include <vector> #include "base/optional.h" @@ -26,6 +27,7 @@ struct FrameTimingDetails; } namespace cc { +class DroppedFrameCounter; class LatencyUkmReporter; // This is used for tracing and reporting the duration of pipeline stages within @@ -93,6 +95,13 @@ class CC_EXPORT CompositorFrameReporter { kStartDrawToSwapStart = 2, kSwapStartToSwapEnd = 3, kSwapEndToPresentationCompositorFrame = 4, + + // This is a breakdown of SwapStartToSwapEnd stage which is optionally + // recorded if querying these timestamps is supported by the platform. + kSwapStartToBufferAvailable = 5, + kBufferAvailableToBufferReady = 6, + kBufferReadyToLatch = 7, + kLatchToSwapEnd = 8, kBreakdownCount }; @@ -111,7 +120,7 @@ class CC_EXPORT CompositorFrameReporter { kBreakdownCount }; - struct StageData { + struct CC_EXPORT StageData { StageType stage_type; base::TimeTicks start_time; base::TimeTicks end_time; @@ -127,8 +136,7 @@ class CC_EXPORT CompositorFrameReporter { std::bitset<static_cast<size_t>(FrameSequenceTrackerType::kMaxType)>; CompositorFrameReporter(const ActiveTrackers& active_trackers, - const viz::BeginFrameId& id, - const base::TimeTicks frame_deadline, + const viz::BeginFrameArgs& args, LatencyUkmReporter* latency_ukm_reporter, bool should_report_metrics); ~CompositorFrameReporter(); @@ -139,8 +147,6 @@ class CC_EXPORT CompositorFrameReporter { std::unique_ptr<CompositorFrameReporter> CopyReporterAtBeginImplStage() const; - const viz::BeginFrameId frame_id_; - // Note that the started stage may be reported to UMA. If the histogram is // intended to be reported then the histograms.xml file must be updated too. void StartStage(StageType stage_type, base::TimeTicks start_time); @@ -183,6 +189,13 @@ class CC_EXPORT CompositorFrameReporter { tick_clock_ = tick_clock; } + void SetDroppedFrameCounter(DroppedFrameCounter* counter) { + dropped_frame_counter_ = counter; + } + void SetHasPartialUpdate() { has_partial_update_ = true; } + + const viz::BeginFrameId& frame_id() const { return args_.frame_id; } + private: void TerminateReporter(); void EndCurrentStage(base::TimeTicks end_time); @@ -213,15 +226,8 @@ class CC_EXPORT CompositorFrameReporter { int stage_type_index, base::TimeDelta latency) const; - // Generate a trace event corresponding to a Viz breakdown under - // SubmitCompositorFrameToPresentationCompositorFrame stage in - // PipelineReporter. This function only generates trace events and does not - // report histograms. - void ReportVizBreakdownTrace(VizBreakdown substage, - const base::TimeTicks start_time, - const base::TimeTicks end_time) const; - - void ReportAllTraceEvents(const char* termination_status_str) const; + void ReportCompositorLatencyTraceEvents() const; + void ReportEventLatencyTraceEvents() const; void EnableReportType(FrameReportType report_type) { report_types_.set(static_cast<size_t>(report_type)); @@ -239,6 +245,7 @@ class CC_EXPORT CompositorFrameReporter { base::TimeTicks Now() const; const bool should_report_metrics_; + const viz::BeginFrameArgs args_; StageData current_stage_; @@ -249,7 +256,7 @@ class CC_EXPORT CompositorFrameReporter { viz::FrameTimingDetails viz_breakdown_; base::TimeTicks viz_start_time_; - base::Optional<base::TimeDelta> + base::Optional<std::pair<base::TimeTicks, base::TimeTicks>> viz_breakdown_list_[static_cast<int>(VizBreakdown::kBreakdownCount)]; // Stage data is recorded here. On destruction these stages will be reported @@ -277,7 +284,6 @@ class CC_EXPORT CompositorFrameReporter { // The time that work on Impl frame is finished. It's only valid if the // reporter is in a stage other than begin impl frame. base::TimeTicks impl_frame_finish_time_; - base::TimeTicks frame_deadline_; // The timestamp of when the frame was marked as not having produced a frame // (through a call to DidNotProduceFrame()). @@ -286,7 +292,11 @@ class CC_EXPORT CompositorFrameReporter { base::Optional<base::TimeTicks> main_frame_abort_time_; const base::TickClock* tick_clock_ = base::DefaultTickClock::GetInstance(); + + DroppedFrameCounter* dropped_frame_counter_ = nullptr; + bool has_partial_update_ = false; }; + } // namespace cc #endif // CC_METRICS_COMPOSITOR_FRAME_REPORTER_H_" diff --git a/chromium/cc/metrics/compositor_frame_reporter_unittest.cc b/chromium/cc/metrics/compositor_frame_reporter_unittest.cc index afd8830e3e3..414655412dd 100644 --- a/chromium/cc/metrics/compositor_frame_reporter_unittest.cc +++ b/chromium/cc/metrics/compositor_frame_reporter_unittest.cc @@ -30,8 +30,7 @@ class CompositorFrameReporterTest : public testing::Test { CompositorFrameReporterTest() : pipeline_reporter_(std::make_unique<CompositorFrameReporter>( CompositorFrameReporter::ActiveTrackers(), - viz::BeginFrameId(), - base::TimeTicks() + base::TimeDelta::FromMilliseconds(16), + viz::BeginFrameArgs(), nullptr, /*should_report_metrics=*/true)) { pipeline_reporter_->set_tick_clock(&test_tick_clock_); diff --git a/chromium/cc/metrics/compositor_frame_reporting_controller.cc b/chromium/cc/metrics/compositor_frame_reporting_controller.cc index cd0ae991606..b19d869c968 100644 --- a/chromium/cc/metrics/compositor_frame_reporting_controller.cc +++ b/chromium/cc/metrics/compositor_frame_reporting_controller.cc @@ -68,11 +68,12 @@ void CompositorFrameReportingController::WillBeginImplFrame( reporter->did_not_produce_frame_time()); } auto reporter = std::make_unique<CompositorFrameReporter>( - active_trackers_, args.frame_id, args.frame_time + (args.interval * 1.5), - latency_ukm_reporter_.get(), should_report_metrics_); + active_trackers_, args, latency_ukm_reporter_.get(), + should_report_metrics_); reporter->set_tick_clock(tick_clock_); reporter->StartStage(StageType::kBeginImplFrameToSendBeginMainFrame, begin_time); + reporter->SetDroppedFrameCounter(dropped_frame_counter_); reporters_[PipelineStage::kBeginImplFrame] = std::move(reporter); } @@ -83,7 +84,7 @@ void CompositorFrameReportingController::WillBeginMainFrame( // C++20 feature. DCHECK_NE(reporters_[PipelineStage::kBeginMainFrame].get(), reporters_[PipelineStage::kBeginImplFrame].get()); - DCHECK_EQ(reporters_[PipelineStage::kBeginImplFrame]->frame_id_, + DCHECK_EQ(reporters_[PipelineStage::kBeginImplFrame]->frame_id(), args.frame_id); reporters_[PipelineStage::kBeginImplFrame]->StartStage( StageType::kSendBeginMainFrameToCommit, Now()); @@ -94,11 +95,11 @@ void CompositorFrameReportingController::WillBeginMainFrame( // beginMain frame before next BeginImplFrame (Not reached the ImplFrame // deadline yet). So will start a new reporter at BeginMainFrame. auto reporter = std::make_unique<CompositorFrameReporter>( - active_trackers_, args.frame_id, - args.frame_time + (args.interval * 1.5), latency_ukm_reporter_.get(), + active_trackers_, args, latency_ukm_reporter_.get(), should_report_metrics_); reporter->set_tick_clock(tick_clock_); reporter->StartStage(StageType::kSendBeginMainFrameToCommit, Now()); + reporter->SetDroppedFrameCounter(dropped_frame_counter_); reporters_[PipelineStage::kBeginMainFrame] = std::move(reporter); } } @@ -107,7 +108,7 @@ void CompositorFrameReportingController::BeginMainFrameAborted( const viz::BeginFrameId& id) { auto& reporter = reporters_[PipelineStage::kBeginMainFrame]; DCHECK(reporter); - DCHECK_EQ(reporter->frame_id_, id); + DCHECK_EQ(reporter->frame_id(), id); reporter->OnAbortBeginMainFrame(Now()); } @@ -169,7 +170,7 @@ void CompositorFrameReportingController::DidSubmitCompositorFrame( // |impl_reporter| is guaranteed to be set, and |main_reporter| will not be // set. if (is_activated_frame_new) { - DCHECK_EQ(reporters_[PipelineStage::kActivate]->frame_id_, + DCHECK_EQ(reporters_[PipelineStage::kActivate]->frame_id(), last_activated_frame_id); // The reporter in activate state can be submitted main_reporter = std::move(reporters_[PipelineStage::kActivate]); @@ -205,6 +206,7 @@ void CompositorFrameReportingController::DidSubmitCompositorFrame( if (reporter) { reporter->StartStage(StageType::kEndActivateToSubmitCompositorFrame, reporter->impl_frame_finish_time()); + reporter->SetHasPartialUpdate(); impl_reporter = std::move(reporter); } } @@ -220,7 +222,7 @@ void CompositorFrameReportingController::DidSubmitCompositorFrame( DCHECK(main_reporter); // If there are impl events, there must be a reporter with // |current_frame_id|. - DCHECK_EQ(main_reporter->frame_id_, current_frame_id); + DCHECK_EQ(main_reporter->frame_id(), current_frame_id); events_metrics.main_event_metrics.reserve( events_metrics.main_event_metrics.size() + events_metrics.impl_event_metrics.size()); @@ -255,7 +257,7 @@ void CompositorFrameReportingController::DidNotProduceFrame( const viz::BeginFrameId& id, FrameSkippedReason skip_reason) { for (auto& stage_reporter : reporters_) { - if (stage_reporter && stage_reporter->frame_id_ == id) { + if (stage_reporter && stage_reporter->frame_id() == id) { // The reporter will be flagged and terminated when replaced by another // reporter. The reporter is not terminated immediately here because it // can still end up producing a frame afterwards. For example, if the @@ -264,7 +266,20 @@ void CompositorFrameReportingController::DidNotProduceFrame( // BeginMain stage, but the main-thread can make updates, which can be // submitted with the next frame. stage_reporter->OnDidNotProduceFrame(skip_reason); - return; + break; + } + } + + // If the compositor has no updates, and the main-thread has not responded to + // the begin-main-frame yet, then it is essentially a dropped frame. To handle + // this case, keep the reporter for the main-thread, but recreate a reporter + // for the dropped-frame. + if (skip_reason == FrameSkippedReason::kWaitingOnMain) { + auto reporter = RestoreReporterAtBeginImpl(id); + if (reporter) { + reporter->OnDidNotProduceFrame(skip_reason); + reporter->TerminateFrame(FrameTerminationStatus::kDidNotProduceFrame, + Now()); } } } @@ -272,7 +287,7 @@ void CompositorFrameReportingController::DidNotProduceFrame( void CompositorFrameReportingController::OnFinishImplFrame( const viz::BeginFrameId& id) { for (auto& reporter : reporters_) { - if (reporter && reporter->frame_id_ == id) { + if (reporter && reporter->frame_id() == id) { reporter->OnFinishImplFrame(Now()); return; } @@ -288,8 +303,10 @@ void CompositorFrameReportingController::DidPresentCompositorFrame( break; auto termination_status = FrameTerminationStatus::kPresentedFrame; - if (submitted_frame->frame_token != frame_token) + if (submitted_frame->frame_token != frame_token || + details.presentation_feedback.failed()) { termination_status = FrameTerminationStatus::kDidNotPresentFrame; + } submitted_frame->reporter->SetVizBreakdown(details); submitted_frame->reporter->TerminateFrame( @@ -356,7 +373,7 @@ bool CompositorFrameReportingController::CanSubmitImplFrame( if (!reporters_[PipelineStage::kBeginImplFrame]) return false; auto& reporter = reporters_[PipelineStage::kBeginImplFrame]; - return (reporter->frame_id_ == id && reporter->did_finish_impl_frame()); + return (reporter->frame_id() == id && reporter->did_finish_impl_frame()); } bool CompositorFrameReportingController::CanSubmitMainFrame( @@ -364,7 +381,7 @@ bool CompositorFrameReportingController::CanSubmitMainFrame( if (!reporters_[PipelineStage::kBeginMainFrame]) return false; auto& reporter = reporters_[PipelineStage::kBeginMainFrame]; - return (reporter->frame_id_ == id && reporter->did_finish_impl_frame() && + return (reporter->frame_id() == id && reporter->did_finish_impl_frame() && reporter->did_abort_main_frame()); } @@ -373,15 +390,15 @@ CompositorFrameReportingController::RestoreReporterAtBeginImpl( const viz::BeginFrameId& id) { auto& main_reporter = reporters_[PipelineStage::kBeginMainFrame]; auto& commit_reporter = reporters_[PipelineStage::kCommit]; - if (main_reporter && main_reporter->frame_id_ == id) + if (main_reporter && main_reporter->frame_id() == id) return main_reporter->CopyReporterAtBeginImplStage(); - if (commit_reporter && commit_reporter->frame_id_ == id) + if (commit_reporter && commit_reporter->frame_id() == id) return commit_reporter->CopyReporterAtBeginImplStage(); return nullptr; } void CompositorFrameReportingController::SetUkmManager(UkmManager* manager) { - latency_ukm_reporter_->SetUkmManager(manager); + latency_ukm_reporter_->set_ukm_manager(manager); } } // namespace cc diff --git a/chromium/cc/metrics/compositor_frame_reporting_controller.h b/chromium/cc/metrics/compositor_frame_reporting_controller.h index fb6b219ce27..2659e92b59d 100644 --- a/chromium/cc/metrics/compositor_frame_reporting_controller.h +++ b/chromium/cc/metrics/compositor_frame_reporting_controller.h @@ -20,6 +20,7 @@ struct FrameTimingDetails; } namespace cc { +class DroppedFrameCounter; class UkmManager; struct BeginMainFrameMetrics; @@ -85,6 +86,10 @@ class CC_EXPORT CompositorFrameReportingController { std::unique_ptr<CompositorFrameReporter>* reporters() { return reporters_; } + void SetDroppedFrameCounter(DroppedFrameCounter* counter) { + dropped_frame_counter_ = counter; + } + protected: struct SubmittedCompositorFrame { uint32_t frame_token; @@ -98,6 +103,9 @@ class CC_EXPORT CompositorFrameReportingController { base::TimeTicks Now() const; bool HasReporterAt(PipelineStage stage) const; + bool next_activate_has_invalidation() const { + return next_activate_has_invalidation_; + } private: void AdvanceReporterStage(PipelineStage start, PipelineStage target); @@ -128,6 +136,8 @@ class CC_EXPORT CompositorFrameReportingController { base::circular_deque<SubmittedCompositorFrame> submitted_compositor_frames_; const base::TickClock* tick_clock_ = base::DefaultTickClock::GetInstance(); + + DroppedFrameCounter* dropped_frame_counter_ = nullptr; }; } // namespace cc diff --git a/chromium/cc/metrics/compositor_frame_reporting_controller_unittest.cc b/chromium/cc/metrics/compositor_frame_reporting_controller_unittest.cc index ca70577d732..68bab0a45c1 100644 --- a/chromium/cc/metrics/compositor_frame_reporting_controller_unittest.cc +++ b/chromium/cc/metrics/compositor_frame_reporting_controller_unittest.cc @@ -524,13 +524,13 @@ TEST_F(CompositorFrameReportingControllerTest, args_3.interval, 0}; reporting_controller_.DidPresentCompositorFrame(1, details); - // Frame for |args_2| was dropped waiting on the main-thread. + // Frames for |args_1| and |args_2| were dropped waiting on the main-thread. histogram_tester.ExpectBucketCount( "CompositorLatency.Type", - CompositorFrameReporter::FrameReportType::kDroppedFrame, 1); + CompositorFrameReporter::FrameReportType::kDroppedFrame, 2); - // Frames for |args_1| and |args_3| were presented, although |args_1| missed - // its deadline. + // Frames for |args_1| and |args_3| were presented with |args_3|, and |args_1| + // missed its deadline. histogram_tester.ExpectBucketCount( "CompositorLatency.Type", CompositorFrameReporter::FrameReportType::kNonDroppedFrame, 2); diff --git a/chromium/cc/metrics/compositor_timing_history.cc b/chromium/cc/metrics/compositor_timing_history.cc index d0cc7d44262..99873a0152f 100644 --- a/chromium/cc/metrics/compositor_timing_history.cc +++ b/chromium/cc/metrics/compositor_timing_history.cc @@ -46,10 +46,6 @@ class CompositorTimingHistory::UMAReporter { // crbug.com/758439: the following functions are used to report timing in // certain conditions targeting blink / compositor animations. // Only the renderer would get the meaningful data. - virtual void AddDrawIntervalWithCompositedAnimations( - base::TimeDelta duration) = 0; - virtual void AddDrawIntervalWithMainThreadAnimations( - base::TimeDelta duration) = 0; virtual void AddDrawIntervalWithCustomPropertyAnimations( base::TimeDelta duration) = 0; }; @@ -310,18 +306,6 @@ class RendererUMAReporter : public CompositorTimingHistory::UMAReporter { interval); } - void AddDrawIntervalWithCompositedAnimations( - base::TimeDelta interval) override { - UMA_HISTOGRAM_CUSTOM_TIMES_VSYNC_ALIGNED( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations", interval); - } - - void AddDrawIntervalWithMainThreadAnimations( - base::TimeDelta interval) override { - UMA_HISTOGRAM_CUSTOM_TIMES_VSYNC_ALIGNED( - "Scheduling.Renderer.DrawIntervalWithMainThreadAnimations", interval); - } - void AddDrawIntervalWithCustomPropertyAnimations( base::TimeDelta interval) override { UMA_HISTOGRAM_CUSTOM_TIMES_VSYNC_ALIGNED( @@ -396,12 +380,6 @@ class BrowserUMAReporter : public CompositorTimingHistory::UMAReporter { // browser rendering fps is not at 60. void AddDrawInterval(base::TimeDelta interval) override {} - void AddDrawIntervalWithCompositedAnimations( - base::TimeDelta interval) override {} - - void AddDrawIntervalWithMainThreadAnimations( - base::TimeDelta interval) override {} - void AddDrawIntervalWithCustomPropertyAnimations( base::TimeDelta interval) override {} @@ -456,10 +434,6 @@ class NullUMAReporter : public CompositorTimingHistory::UMAReporter { ~NullUMAReporter() override = default; void AddBeginMainFrameIntervalCritical(base::TimeDelta interval) override {} void AddDrawInterval(base::TimeDelta interval) override {} - void AddDrawIntervalWithCompositedAnimations( - base::TimeDelta inverval) override {} - void AddDrawIntervalWithMainThreadAnimations( - base::TimeDelta inverval) override {} void AddDrawIntervalWithCustomPropertyAnimations( base::TimeDelta inverval) override {} void AddBeginImplFrameLatency(base::TimeDelta delta) override {} @@ -861,10 +835,6 @@ void CompositorTimingHistory::WillDraw() { } void CompositorTimingHistory::DidDraw(bool used_new_active_tree, - size_t composited_animations_count, - size_t main_thread_animations_count, - bool current_frame_had_raf, - bool next_frame_has_pending_raf, bool has_custom_property_animations) { DCHECK_NE(base::TimeTicks(), draw_start_time_); base::TimeTicks draw_end_time = Now(); @@ -898,42 +868,16 @@ void CompositorTimingHistory::DidDraw(bool used_new_active_tree, TRACE_ID_LOCAL(g_num_long_draw_intervals), draw_end_time); g_num_long_draw_intervals++; } - if (composited_animations_count > 0 && - previous_frame_had_composited_animations_) - uma_reporter_->AddDrawIntervalWithCompositedAnimations(draw_interval); if (has_custom_property_animations && previous_frame_had_custom_property_animations_) uma_reporter_->AddDrawIntervalWithCustomPropertyAnimations(draw_interval); } - previous_frame_had_composited_animations_ = composited_animations_count > 0; previous_frame_had_custom_property_animations_ = has_custom_property_animations; draw_end_time_prev_ = draw_end_time; - if (used_new_active_tree) { - bool current_main_frame_had_visual_update = - main_thread_animations_count > 0 || current_frame_had_raf; - bool previous_main_frame_had_visual_update = - previous_frame_had_main_thread_animations_ || previous_frame_had_raf_; - if (current_main_frame_had_visual_update && - previous_main_frame_had_visual_update) { - base::TimeDelta draw_interval = - draw_end_time - new_active_tree_draw_end_time_prev_; - uma_reporter_->AddDrawIntervalWithMainThreadAnimations(draw_interval); - } - previous_frame_had_main_thread_animations_ = - main_thread_animations_count > 0; - // It's possible that two consecutive main frames both run a rAF but are - // separated by idle time (for example: calling requestAnimationFrame from a - // setInterval function, with nothing else producing a main frame - // in-between). To avoid incorrectly counting those cases as long draw - // intervals, we only update previous_frame_had_raf_ if the current frame - // also already has a future raf scheduled. - previous_frame_had_raf_ = - current_frame_had_raf && next_frame_has_pending_raf; - + if (used_new_active_tree) new_active_tree_draw_end_time_prev_ = draw_end_time; - } draw_start_time_ = base::TimeTicks(); } diff --git a/chromium/cc/metrics/compositor_timing_history.h b/chromium/cc/metrics/compositor_timing_history.h index 1d265a8419a..a4ff2503787 100644 --- a/chromium/cc/metrics/compositor_timing_history.h +++ b/chromium/cc/metrics/compositor_timing_history.h @@ -91,10 +91,6 @@ class CC_EXPORT CompositorTimingHistory { void DidActivate(); void WillDraw(); void DidDraw(bool used_new_active_tree, - size_t composited_animations_count, - size_t main_thread_animations_count, - bool current_frame_had_raf, - bool next_frame_has_pending_raf, bool has_custom_property_animations); void DidSubmitCompositorFrame( uint32_t frame_token, @@ -140,7 +136,6 @@ class CC_EXPORT CompositorTimingHistory { bool compositor_drawing_continuously_; base::TimeTicks begin_main_frame_end_time_prev_; base::TimeTicks new_active_tree_draw_end_time_prev_; - base::TimeTicks new_active_tree_draw_end_time_prev_committing_continuously_; base::TimeTicks draw_end_time_prev_; // If you add any history here, please remember to reset it in @@ -179,10 +174,7 @@ class CC_EXPORT CompositorTimingHistory { CompositorFrameReportingController* compositor_frame_reporting_controller_; // Used only for reporting animation targeted UMA. - bool previous_frame_had_composited_animations_ = false; - bool previous_frame_had_main_thread_animations_ = false; bool previous_frame_had_custom_property_animations_ = false; - bool previous_frame_had_raf_ = false; TreePriority tree_priority_ = SAME_PRIORITY_FOR_BOTH_TREES; }; diff --git a/chromium/cc/metrics/compositor_timing_history_unittest.cc b/chromium/cc/metrics/compositor_timing_history_unittest.cc index b5b713355d2..82c35dcad08 100644 --- a/chromium/cc/metrics/compositor_timing_history_unittest.cc +++ b/chromium/cc/metrics/compositor_timing_history_unittest.cc @@ -4,7 +4,6 @@ #include "cc/metrics/compositor_timing_history.h" -#include "base/test/metrics/histogram_tester.h" #include "cc/debug/rendering_stats_instrumentation.h" #include "cc/test/fake_compositor_frame_reporting_controller.h" #include "testing/gtest/include/gtest/gtest.h" @@ -53,43 +52,6 @@ class CompositorTimingHistoryTest : public testing::Test { base::TimeTicks Now() { return now_; } - // TODO(xidachen): the composited_animations_count should just be 0. - void DrawMainFrame(int advance_ms, - int composited_animations_count, - int main_thread_animations_count, - bool current_frame_had_raf = false, - bool next_frame_has_pending_raf = false) { - timing_history_.WillBeginMainFrame(getFakeBeginFrameArg()); - timing_history_.BeginMainFrameStarted(Now()); - timing_history_.WillCommit(); - timing_history_.DidCommit(); - timing_history_.ReadyToActivate(); - timing_history_.WillActivate(); - timing_history_.DidActivate(); - timing_history_.WillDraw(); - AdvanceNowBy(base::TimeDelta::FromMicroseconds(advance_ms)); - timing_history_.DidDraw(true, composited_animations_count, - main_thread_animations_count, current_frame_had_raf, - next_frame_has_pending_raf, false); - } - - void DrawImplFrame(int advance_ms, - int composited_animations_count, - int main_thread_animations_count, - bool has_custom_property_animation) { - viz::BeginFrameArgs args_ = getFakeBeginFrameArg(); - timing_history_.WillBeginMainFrame(args_); - timing_history_.BeginMainFrameStarted(Now()); - timing_history_.BeginMainFrameAborted(args_.frame_id); - timing_history_.WillActivate(); - timing_history_.DidActivate(); - timing_history_.WillDraw(); - AdvanceNowBy(base::TimeDelta::FromMicroseconds(advance_ms)); - timing_history_.DidDraw(false, composited_animations_count, - main_thread_animations_count, false, false, - has_custom_property_animation); - } - protected: std::unique_ptr<RenderingStatsInstrumentation> rendering_stats_; std::unique_ptr<CompositorFrameReportingController> reporting_controller_; @@ -148,7 +110,7 @@ TEST_F(CompositorTimingHistoryTest, AllSequential_Commit) { AdvanceNowBy(one_second); timing_history_.WillDraw(); AdvanceNowBy(draw_duration); - timing_history_.DidDraw(true, 0, 0, false, false, false); + timing_history_.DidDraw(true, false); EXPECT_EQ(begin_main_frame_queue_duration, timing_history_.BeginMainFrameQueueDurationCriticalEstimate()); @@ -200,7 +162,7 @@ TEST_F(CompositorTimingHistoryTest, AllSequential_BeginMainFrameAborted) { AdvanceNowBy(one_second); timing_history_.WillDraw(); AdvanceNowBy(draw_duration); - timing_history_.DidDraw(false, 0, 0, false, false, false); + timing_history_.DidDraw(false, false); EXPECT_EQ(base::TimeDelta(), timing_history_.BeginMainFrameQueueDurationCriticalEstimate()); @@ -320,179 +282,5 @@ TEST_F(CompositorTimingHistoryTest, BeginMainFrames_NewCriticalSlower) { timing_history_.BeginMainFrameQueueDurationNotCriticalEstimate()); } -void TestAnimationUMA(const base::HistogramTester& histogram_tester, - base::HistogramBase::Count composited_animation_frames, - base::HistogramBase::Count main_thread_animation_frames) { - histogram_tester.ExpectTotalCount( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations2", - composited_animation_frames); - histogram_tester.ExpectTotalCount( - "Scheduling.Renderer.DrawIntervalWithMainThreadAnimations2", - main_thread_animation_frames); -} - -TEST_F(CompositorTimingHistoryTest, AnimationNotReported) { - base::HistogramTester histogram_tester; - - // Initial frame has no main-thread animations or rAF. - DrawMainFrame(123, 0, 0); - TestAnimationUMA(histogram_tester, 0, 0); - - // The next frame has one composited and one main thread animation running, - // but as the previous frame had no animation we shouldn't report anything. - DrawMainFrame(456, 1, 1); - TestAnimationUMA(histogram_tester, 0, 0); - - DrawMainFrame(123, 0, 0); - TestAnimationUMA(histogram_tester, 0, 0); - - // The next frame has just one main thread animation running, but again as the - // previous frame had no animation we shouldn't report anything. - DrawMainFrame(456, 0, 1); - TestAnimationUMA(histogram_tester, 0, 0); - - DrawMainFrame(123, 0, 0); - TestAnimationUMA(histogram_tester, 0, 0); - - // The next frame has no main thread animations but did have a rAF callback. - // Again as the previous frame had no visual change we shouldn't report. - DrawMainFrame(123, 0, 0, true); - TestAnimationUMA(histogram_tester, 0, 0); - - DrawMainFrame(123, 0, 0); - TestAnimationUMA(histogram_tester, 0, 0); - - // Finally, test the combination of both main thread animations and rAF - // callbacks being called. - DrawMainFrame(123, 1, 2, true); - TestAnimationUMA(histogram_tester, 0, 0); -} - -TEST_F(CompositorTimingHistoryTest, ConsecutiveFramesAnimationsReported) { - base::HistogramTester histogram_tester; - - DrawMainFrame(123, 1, 0); - TestAnimationUMA(histogram_tester, 0, 0); - - DrawMainFrame(456, 1, 0); - TestAnimationUMA(histogram_tester, 1, 0); - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations2", 456, 1); - - DrawMainFrame(321, 0, 1); - TestAnimationUMA(histogram_tester, 1, 0); - - DrawMainFrame(654, 0, 1); - TestAnimationUMA(histogram_tester, 1, 1); - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithMainThreadAnimations2", 654, 1); - - DrawMainFrame(123, 0, 1); - TestAnimationUMA(histogram_tester, 1, 2); - - DrawMainFrame(456, 0, 1); - TestAnimationUMA(histogram_tester, 1, 3); - - // Main thread and rAF animations are both considered to be part of the same - // animation type. - DrawMainFrame(789, 0, 0, true, true); - TestAnimationUMA(histogram_tester, 1, 4); - - DrawMainFrame(987, 0, 1, false); - TestAnimationUMA(histogram_tester, 1, 5); - - // However if there is no pending rAF for a frame, we don't count the one - // after it as being linked. - DrawMainFrame(789, 0, 0, true, false); - TestAnimationUMA(histogram_tester, 1, 6); - - DrawMainFrame(987, 0, 0, true, true); - TestAnimationUMA(histogram_tester, 1, 6); -} - -TEST_F(CompositorTimingHistoryTest, InterFrameAnimationsNotReported) { - base::HistogramTester histogram_tester; - - DrawMainFrame(123, 0, 1); - TestAnimationUMA(histogram_tester, 0, 0); - - // The previous frame had a main thread animation, where the current one is - // main thread compositable animation, we don't measure the timing from a - // different animation type. - DrawMainFrame(456, 0, 1); - TestAnimationUMA(histogram_tester, 0, 1); - - DrawMainFrame(321, 1, 0); - TestAnimationUMA(histogram_tester, 0, 1); - - DrawMainFrame(654, 0, 1); - TestAnimationUMA(histogram_tester, 0, 1); - - DrawMainFrame(123, 1, 0); - TestAnimationUMA(histogram_tester, 0, 1); -} - -TEST_F(CompositorTimingHistoryTest, AnimationsWithNewActiveTreeNotUsed) { - base::HistogramTester histogram_tester; - - DrawImplFrame(123, 1, 1, false); - TestAnimationUMA(histogram_tester, 0, 0); - - DrawImplFrame(456, 1, 0, false); - TestAnimationUMA(histogram_tester, 1, 0); - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations2", 456, 1); - - DrawMainFrame(321, 0, 1); - TestAnimationUMA(histogram_tester, 1, 0); - - // This frame verifies that we record that there is a composited animation, - // so in the next frame when there is a composited animation, we report it. - DrawImplFrame(234, 1, 1, false); - TestAnimationUMA(histogram_tester, 1, 0); - - // Even though the previous frame had no main thread animation, we report it - // in this frame because the previous main frame had a main thread animation - // with the time between main frame draws. - DrawMainFrame(654, 1, 1); - TestAnimationUMA(histogram_tester, 2, 1); - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations2", 654, 1); - // The recorded time for this main thread animation should be the total time - // between the two new tree activations, which is 234 + 654 = 888. - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithMainThreadAnimations2", 888, 1); - - DrawImplFrame(123, 1, 0, false); - TestAnimationUMA(histogram_tester, 3, 1); - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations2", 123, 1); -} - -TEST_F(CompositorTimingHistoryTest, CustomPropertyAnimations) { - base::HistogramTester histogram_tester; - - DrawImplFrame(123, 1, 0, true); - TestAnimationUMA(histogram_tester, 0, 0); - - DrawImplFrame(456, 1, 0, true); - TestAnimationUMA(histogram_tester, 1, 0); - - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations2", 456, 1); - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCustomPropertyAnimations2", 456, 1); - - DrawImplFrame(1234, 1, 0, false); - DrawImplFrame(2345, 1, 0, true); - TestAnimationUMA(histogram_tester, 3, 0); - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCompositedAnimations2", 2345, 1); - // This impl frame does have custom property animation, but the previous impl - // frame doesn't, so we won't report it. - histogram_tester.ExpectBucketCount( - "Scheduling.Renderer.DrawIntervalWithCustomPropertyAnimations2", 2345, 0); -} - } // namespace } // namespace cc diff --git a/chromium/cc/metrics/dropped_frame_counter.cc b/chromium/cc/metrics/dropped_frame_counter.cc new file mode 100644 index 00000000000..56564a2415f --- /dev/null +++ b/chromium/cc/metrics/dropped_frame_counter.cc @@ -0,0 +1,45 @@ +// Copyright 2020 The Chromium 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 "cc/metrics/dropped_frame_counter.h" + +#include <stddef.h> + +#include <limits> + +#include "base/memory/ptr_util.h" +#include "base/metrics/histogram_macros.h" + +namespace cc { + +DroppedFrameCounter::DroppedFrameCounter() = default; + +uint32_t DroppedFrameCounter::GetAverageThroughput() const { + size_t good_frames = 0; + for (auto it = --end(); it; --it) { + if (**it == kFrameStateComplete) + ++good_frames; + } + double throughput = 100. * good_frames / ring_buffer_.BufferSize(); + return static_cast<uint32_t>(throughput); +} + +void DroppedFrameCounter::AddGoodFrame() { + ring_buffer_.SaveToBuffer(kFrameStateComplete); + ++total_frames_; +} + +void DroppedFrameCounter::AddPartialFrame() { + ring_buffer_.SaveToBuffer(kFrameStatePartial); + ++total_frames_; + ++total_partial_; +} + +void DroppedFrameCounter::AddDroppedFrame() { + ring_buffer_.SaveToBuffer(kFrameStateDropped); + ++total_frames_; + ++total_dropped_; +} + +} // namespace cc diff --git a/chromium/cc/metrics/dropped_frame_counter.h b/chromium/cc/metrics/dropped_frame_counter.h new file mode 100644 index 00000000000..4929295ddce --- /dev/null +++ b/chromium/cc/metrics/dropped_frame_counter.h @@ -0,0 +1,55 @@ +// Copyright 2020 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CC_METRICS_DROPPED_FRAME_COUNTER_H_ +#define CC_METRICS_DROPPED_FRAME_COUNTER_H_ + +#include <stddef.h> + +#include <memory> + +#include "base/containers/ring_buffer.h" +#include "base/time/time.h" + +namespace cc { + +// This class maintains a counter for produced/dropped frames, and can be used +// to estimate the recent throughput. +class DroppedFrameCounter { + public: + enum FrameState { + kFrameStateDropped, + kFrameStatePartial, + kFrameStateComplete + }; + DroppedFrameCounter(); + + DroppedFrameCounter(const DroppedFrameCounter&) = delete; + DroppedFrameCounter& operator=(const DroppedFrameCounter&) = delete; + + size_t frame_history_size() const { return ring_buffer_.BufferSize(); } + size_t total_frames() const { return total_frames_; } + size_t total_compositor_dropped() const { return total_dropped_; } + size_t total_main_dropped() const { return total_partial_; } + + uint32_t GetAverageThroughput() const; + + typedef base::RingBuffer<FrameState, 180> RingBufferType; + RingBufferType::Iterator begin() const { return ring_buffer_.Begin(); } + RingBufferType::Iterator end() const { return ring_buffer_.End(); } + + void AddGoodFrame(); + void AddPartialFrame(); + void AddDroppedFrame(); + + private: + RingBufferType ring_buffer_; + size_t total_frames_ = 0; + size_t total_partial_ = 0; + size_t total_dropped_ = 0; +}; + +} // namespace cc + +#endif // CC_METRICS_DROPPED_FRAME_COUNTER_H_ diff --git a/chromium/cc/metrics/event_metrics.cc b/chromium/cc/metrics/event_metrics.cc index 326eaee70a1..951cdfc2ceb 100644 --- a/chromium/cc/metrics/event_metrics.cc +++ b/chromium/cc/metrics/event_metrics.cc @@ -4,98 +4,130 @@ #include "cc/metrics/event_metrics.h" +#include <utility> + #include "base/check.h" #include "base/memory/ptr_util.h" #include "base/notreached.h" #include "base/stl_util.h" namespace cc { +namespace { + +constexpr struct { + EventMetrics::EventType metrics_event_type; + ui::EventType ui_event_type; + const char* name; +} kWhitelistedEvents[] = { +#define EVENT_TYPE(name, ui_type) \ + { EventMetrics::EventType::k##name, ui_type, #name } + EVENT_TYPE(MousePressed, ui::ET_MOUSE_PRESSED), + EVENT_TYPE(MouseReleased, ui::ET_MOUSE_RELEASED), + EVENT_TYPE(MouseWheel, ui::ET_MOUSEWHEEL), + EVENT_TYPE(KeyPressed, ui::ET_KEY_PRESSED), + EVENT_TYPE(KeyReleased, ui::ET_KEY_RELEASED), + EVENT_TYPE(TouchPressed, ui::ET_TOUCH_PRESSED), + EVENT_TYPE(TouchReleased, ui::ET_TOUCH_RELEASED), + EVENT_TYPE(TouchMoved, ui::ET_TOUCH_MOVED), + EVENT_TYPE(GestureScrollBegin, ui::ET_GESTURE_SCROLL_BEGIN), + EVENT_TYPE(GestureScrollUpdate, ui::ET_GESTURE_SCROLL_UPDATE), + EVENT_TYPE(GestureScrollEnd, ui::ET_GESTURE_SCROLL_END), + EVENT_TYPE(GestureDoubleTap, ui::ET_GESTURE_DOUBLE_TAP), + EVENT_TYPE(GestureLongPress, ui::ET_GESTURE_LONG_PRESS), + EVENT_TYPE(GestureLongTap, ui::ET_GESTURE_LONG_TAP), + EVENT_TYPE(GestureShowPress, ui::ET_GESTURE_SHOW_PRESS), + EVENT_TYPE(GestureTap, ui::ET_GESTURE_TAP), + EVENT_TYPE(GestureTapCancel, ui::ET_GESTURE_TAP_CANCEL), + EVENT_TYPE(GestureTapDown, ui::ET_GESTURE_TAP_DOWN), + EVENT_TYPE(GestureTapUnconfirmed, ui::ET_GESTURE_TAP_UNCONFIRMED), + EVENT_TYPE(GestureTwoFingerTap, ui::ET_GESTURE_TWO_FINGER_TAP), +#undef EVENT_TYPE +}; +static_assert(base::size(kWhitelistedEvents) == + static_cast<int>(EventMetrics::EventType::kMaxValue) + 1, + "EventMetrics::EventType has changed."); + +constexpr struct { + EventMetrics::ScrollType metrics_scroll_type; + ui::ScrollInputType ui_scroll_type; + const char* name; +} kScrollTypes[] = { +#define SCROLL_TYPE(name, ui_type) \ + { EventMetrics::ScrollType::k##name, ui_type, #name } + SCROLL_TYPE(Autoscroll, ui::ScrollInputType::kAutoscroll), + SCROLL_TYPE(Scrollbar, ui::ScrollInputType::kScrollbar), + SCROLL_TYPE(Touchscreen, ui::ScrollInputType::kTouchscreen), + SCROLL_TYPE(Wheel, ui::ScrollInputType::kWheel), +#undef SCROLL_TYPE +}; +static_assert(base::size(kScrollTypes) == + static_cast<int>(EventMetrics::ScrollType::kMaxValue) + 1, + "EventMetrics::ScrollType has changed."); + +base::Optional<EventMetrics::EventType> ToWhitelistedEventType( + ui::EventType ui_event_type) { + for (size_t i = 0; i < base::size(kWhitelistedEvents); i++) { + if (ui_event_type == kWhitelistedEvents[i].ui_event_type) { + EventMetrics::EventType metrics_event_type = + static_cast<EventMetrics::EventType>(i); + DCHECK_EQ(metrics_event_type, kWhitelistedEvents[i].metrics_event_type); + return metrics_event_type; + } + } + return base::nullopt; +} + +base::Optional<EventMetrics::ScrollType> ToScrollType( + const base::Optional<ui::ScrollInputType>& scroll_input_type) { + if (!scroll_input_type) + return base::nullopt; + + for (size_t i = 0; i < base::size(kScrollTypes); i++) { + if (*scroll_input_type == kScrollTypes[i].ui_scroll_type) { + EventMetrics::ScrollType metrics_scroll_type = + static_cast<EventMetrics::ScrollType>(i); + DCHECK_EQ(metrics_scroll_type, kScrollTypes[i].metrics_scroll_type); + return metrics_scroll_type; + } + } + NOTREACHED(); + return base::nullopt; +} + +} // namespace std::unique_ptr<EventMetrics> EventMetrics::Create( ui::EventType type, base::TimeTicks time_stamp, base::Optional<ui::ScrollInputType> scroll_input_type) { - switch (type) { - case ui::ET_MOUSE_PRESSED: - case ui::ET_MOUSE_RELEASED: - case ui::ET_MOUSEWHEEL: - case ui::ET_KEY_PRESSED: - case ui::ET_KEY_RELEASED: - case ui::ET_TOUCH_PRESSED: - case ui::ET_TOUCH_RELEASED: - case ui::ET_TOUCH_MOVED: - case ui::ET_GESTURE_SCROLL_BEGIN: - case ui::ET_GESTURE_SCROLL_UPDATE: - case ui::ET_GESTURE_SCROLL_END: - return base::WrapUnique( - new EventMetrics(type, time_stamp, scroll_input_type)); - default: - return nullptr; - } + base::Optional<EventType> whitelisted_type = ToWhitelistedEventType(type); + if (!whitelisted_type) + return nullptr; + return base::WrapUnique(new EventMetrics(*whitelisted_type, time_stamp, + ToScrollType(scroll_input_type))); } -EventMetrics::EventMetrics( - ui::EventType type, - base::TimeTicks time_stamp, - base::Optional<ui::ScrollInputType> scroll_input_type) - : type_(type), - time_stamp_(time_stamp), - scroll_input_type_(scroll_input_type) {} +EventMetrics::EventMetrics(EventType type, + base::TimeTicks time_stamp, + base::Optional<ScrollType> scroll_type) + : type_(type), time_stamp_(time_stamp), scroll_type_(scroll_type) {} EventMetrics::EventMetrics(const EventMetrics&) = default; EventMetrics& EventMetrics::operator=(const EventMetrics&) = default; const char* EventMetrics::GetTypeName() const { - switch (type_) { - case ui::ET_MOUSE_PRESSED: - return "MousePressed"; - case ui::ET_MOUSE_RELEASED: - return "MouseReleased"; - case ui::ET_MOUSEWHEEL: - return "MouseWheel"; - case ui::ET_KEY_PRESSED: - // TODO(crbug/1071645): Currently, all ET_KEY_PRESSED events are reported - // under EventLatency.KeyPressed histogram. This includes both key-down - // and key-char events. Consider reporting them separately. - return "KeyPressed"; - case ui::ET_KEY_RELEASED: - return "KeyReleased"; - case ui::ET_TOUCH_PRESSED: - return "TouchPressed"; - case ui::ET_TOUCH_RELEASED: - return "TouchReleased"; - case ui::ET_TOUCH_MOVED: - return "TouchMoved"; - case ui::ET_GESTURE_SCROLL_BEGIN: - return "GestureScrollBegin"; - case ui::ET_GESTURE_SCROLL_UPDATE: - return "GestureScrollUpdate"; - case ui::ET_GESTURE_SCROLL_END: - return "GestureScrollEnd"; - default: - NOTREACHED(); - return nullptr; - } + return kWhitelistedEvents[static_cast<int>(type_)].name; } const char* EventMetrics::GetScrollTypeName() const { - DCHECK(scroll_input_type_) << "Event is not a scroll event"; - - switch (*scroll_input_type_) { - case ui::ScrollInputType::kTouchscreen: - return "Touchscreen"; - case ui::ScrollInputType::kWheel: - return "Wheel"; - case ui::ScrollInputType::kAutoscroll: - return "Autoscroll"; - case ui::ScrollInputType::kScrollbar: - return "Scrollbar"; - } + DCHECK(scroll_type_) << "Event is not a scroll event."; + + return kScrollTypes[static_cast<int>(*scroll_type_)].name; } bool EventMetrics::operator==(const EventMetrics& other) const { - return std::tie(type_, time_stamp_, scroll_input_type_) == - std::tie(other.type_, other.time_stamp_, other.scroll_input_type_); + return std::tie(type_, time_stamp_, scroll_type_) == + std::tie(other.type_, other.time_stamp_, other.scroll_type_); } // EventMetricsSet diff --git a/chromium/cc/metrics/event_metrics.h b/chromium/cc/metrics/event_metrics.h index 8de2fc58be9..df37365b7ed 100644 --- a/chromium/cc/metrics/event_metrics.h +++ b/chromium/cc/metrics/event_metrics.h @@ -6,6 +6,7 @@ #define CC_METRICS_EVENT_METRICS_H_ #include <memory> +#include <vector> #include "base/optional.h" #include "base/time/time.h" @@ -19,6 +20,45 @@ namespace cc { // latency metrics. class CC_EXPORT EventMetrics { public: + // Whitelisted event types. This list should be in the same order as values of + // EventLatencyEventType enum from enums.xml file. + enum class EventType { + kMousePressed, + kMouseReleased, + kMouseWheel, + // TODO(crbug/1071645): Currently, all ET_KEY_PRESSED events are reported + // under EventLatency.KeyPressed histogram. This includes both key-down and + // key-char events. Consider reporting them separately. + kKeyPressed, + kKeyReleased, + kTouchPressed, + kTouchReleased, + kTouchMoved, + kGestureScrollBegin, + kGestureScrollUpdate, + kGestureScrollEnd, + kGestureDoubleTap, + kGestureLongPress, + kGestureLongTap, + kGestureShowPress, + kGestureTap, + kGestureTapCancel, + kGestureTapDown, + kGestureTapUnconfirmed, + kGestureTwoFingerTap, + kMaxValue = kGestureTwoFingerTap, + }; + + // Type of scroll events. This list should be in the same order as values of + // EventLatencyScrollInputType enum from enums.xml file. + enum class ScrollType { + kAutoscroll, + kScrollbar, + kTouchscreen, + kWheel, + kMaxValue = kWheel, + }; + // Returns a new instance if |type| is a whitelisted event type. Otherwise, // returns nullptr. static std::unique_ptr<EventMetrics> Create( @@ -29,36 +69,33 @@ class CC_EXPORT EventMetrics { EventMetrics(const EventMetrics&); EventMetrics& operator=(const EventMetrics&); - // Returns a string representing event type. Should only be called for - // whitelisted event types. - const char* GetTypeName() const; - - // Returns a string representing scroll input type. Should only be called for - // scroll events. - const char* GetScrollTypeName() const; + EventType type() const { return type_; } - ui::EventType type() const { return type_; } + // Returns a string representing event type. + const char* GetTypeName() const; base::TimeTicks time_stamp() const { return time_stamp_; } - const base::Optional<ui::ScrollInputType>& scroll_input_type() const { - return scroll_input_type_; - } + const base::Optional<ScrollType>& scroll_type() const { return scroll_type_; } + + // Returns a string representing input type for a scroll event. Should only be + // called for scroll events. + const char* GetScrollTypeName() const; // Used in tests to check expectations on EventMetrics objects. bool operator==(const EventMetrics& other) const; private: - EventMetrics(ui::EventType type, + EventMetrics(EventType type, base::TimeTicks time_stamp, - base::Optional<ui::ScrollInputType> scroll_input_type); + base::Optional<ScrollType> scroll_type); - ui::EventType type_; + EventType type_; base::TimeTicks time_stamp_; // Only available for scroll events and represents the type of input device // for the event. - base::Optional<ui::ScrollInputType> scroll_input_type_; + base::Optional<ScrollType> scroll_type_; }; // Struct storing event metrics from both main and impl threads. diff --git a/chromium/cc/metrics/frame_sequence_metrics.cc b/chromium/cc/metrics/frame_sequence_metrics.cc index 0cefe55fd51..5933096b855 100644 --- a/chromium/cc/metrics/frame_sequence_metrics.cc +++ b/chromium/cc/metrics/frame_sequence_metrics.cc @@ -4,6 +4,10 @@ #include "cc/metrics/frame_sequence_metrics.h" +#include <memory> +#include <string> +#include <utility> + #include "base/metrics/histogram.h" #include "base/metrics/histogram_macros.h" #include "base/strings/strcat.h" @@ -91,13 +95,20 @@ bool IsInteractionType(FrameSequenceTrackerType sequence_type) { FrameSequenceMetrics::FrameSequenceMetrics(FrameSequenceTrackerType type, ThroughputUkmReporter* ukm_reporter) : type_(type), throughput_ukm_reporter_(ukm_reporter) { - TRACE_EVENT_NESTABLE_ASYNC_BEGIN1( - "cc,benchmark", "FrameSequenceTracker", TRACE_ID_LOCAL(this), "name", - FrameSequenceTracker::GetFrameSequenceTrackerTypeName(type_)); } -FrameSequenceMetrics::~FrameSequenceMetrics() { +FrameSequenceMetrics::~FrameSequenceMetrics() = default; + +void FrameSequenceMetrics::ReportLeftoverData() { if (HasDataLeftForReporting()) { + // Do this before ReportMetrics() which clears the throughput data. + // TODO(xidachen): Find a way to make ThroughputUkmReporter to directly talk + // to LayerTreeHostClient, and submit throughput data. Instead of storing + // the values in ThroughputUkmReporter. + if (type_ == FrameSequenceTrackerType::kUniversal && + HasEnoughDataForReporting()) { + throughput_ukm_reporter_->ComputeUniversalThroughput(this); + } ReportMetrics(); } } @@ -136,6 +147,8 @@ FrameSequenceMetrics::ThreadType FrameSequenceMetrics::GetEffectiveThread() return ThreadType::kSlower; case FrameSequenceTrackerType::kCustom: + return ThreadType::kMain; + case FrameSequenceTrackerType::kMaxType: NOTREACHED(); } @@ -144,6 +157,8 @@ FrameSequenceMetrics::ThreadType FrameSequenceMetrics::GetEffectiveThread() void FrameSequenceMetrics::Merge( std::unique_ptr<FrameSequenceMetrics> metrics) { + // Merging custom trackers are not supported. + DCHECK_NE(type_, FrameSequenceTrackerType::kCustom); DCHECK_EQ(type_, metrics->type_); DCHECK_EQ(GetEffectiveThread(), metrics->GetEffectiveThread()); impl_throughput_.Merge(metrics->impl_throughput_); @@ -169,6 +184,16 @@ bool FrameSequenceMetrics::HasDataLeftForReporting() const { main_throughput_.frames_expected > 0; } +void FrameSequenceMetrics::AdoptTrace(FrameSequenceMetrics* adopt_from) { + DCHECK(!trace_data_.trace_id); + trace_data_.trace_id = adopt_from->trace_data_.trace_id; + adopt_from->trace_data_.trace_id = nullptr; +} + +void FrameSequenceMetrics::AdvanceTrace(base::TimeTicks timestamp) { + trace_data_.Advance(timestamp); +} + void FrameSequenceMetrics::ComputeAggregatedThroughput() { // Whenever we are expecting and producing main frames, we are expecting and // producing impl frames as well. As an example, if we expect one main frame @@ -183,10 +208,11 @@ void FrameSequenceMetrics::ComputeAggregatedThroughput() { void FrameSequenceMetrics::ReportMetrics() { DCHECK_LE(impl_throughput_.frames_produced, impl_throughput_.frames_expected); DCHECK_LE(main_throughput_.frames_produced, main_throughput_.frames_expected); - TRACE_EVENT_NESTABLE_ASYNC_END2( - "cc,benchmark", "FrameSequenceTracker", TRACE_ID_LOCAL(this), "args", - ThroughputData::ToTracedValue(impl_throughput_, main_throughput_), - "checkerboard", frames_checkerboarded_); + DCHECK_LE(aggregated_throughput_.frames_produced, + aggregated_throughput_.frames_expected); + + // Terminates |trace_data_| for all types of FrameSequenceTracker. + trace_data_.Terminate(); if (type_ == FrameSequenceTrackerType::kCustom) { DCHECK(!custom_reporter_.is_null()); @@ -199,8 +225,6 @@ void FrameSequenceMetrics::ReportMetrics() { return; } - ComputeAggregatedThroughput(); - // Report the throughput metrics. base::Optional<int> impl_throughput_percent = ThroughputData::ReportHistogram( this, ThreadType::kCompositor, @@ -220,7 +244,8 @@ void FrameSequenceMetrics::ReportMetrics() { this, ThreadType::kSlower, GetIndexForMetric(FrameSequenceMetrics::ThreadType::kSlower, type_), aggregated_throughput_); - if (aggregated_throughput_percent.has_value() && throughput_ukm_reporter_) { + if (aggregated_throughput_percent.has_value() && throughput_ukm_reporter_ && + type_ != FrameSequenceTrackerType::kUniversal) { throughput_ukm_reporter_->ReportThroughputUkm( aggregated_throughput_percent, impl_throughput_percent, main_throughput_percent, type_); @@ -312,9 +337,7 @@ base::Optional<int> FrameSequenceMetrics::ThroughputData::ReportHistogram( // Throughput means the percent of frames that was expected to show on the // screen but didn't. In other words, the lower the throughput is, the // smoother user experience. - const int percent = - std::ceil(100 * (data.frames_expected - data.frames_produced) / - static_cast<double>(data.frames_expected)); + const int percent = data.DroppedFramePercent(); const bool is_animation = ShouldReportForAnimation(sequence_type, thread_type); @@ -323,6 +346,11 @@ base::Optional<int> FrameSequenceMetrics::ThroughputData::ReportHistogram( ThroughputUkmReporter* const ukm_reporter = metrics->ukm_reporter(); if (is_animation) { + TRACE_EVENT_INSTANT2("cc,benchmark", "PercentDroppedFrames.AllAnimations", + TRACE_EVENT_SCOPE_THREAD, "frames_expected", + data.frames_expected, "frames_produced", + data.frames_produced); + UMA_HISTOGRAM_PERCENTAGE( "Graphics.Smoothness.PercentDroppedFrames.AllAnimations", percent); if (ukm_reporter) { @@ -332,6 +360,10 @@ base::Optional<int> FrameSequenceMetrics::ThroughputData::ReportHistogram( } if (is_interaction) { + TRACE_EVENT_INSTANT2("cc,benchmark", "PercentDroppedFrames.AllInteractions", + TRACE_EVENT_SCOPE_THREAD, "frames_expected", + data.frames_expected, "frames_produced", + data.frames_produced); UMA_HISTOGRAM_PERCENTAGE( "Graphics.Smoothness.PercentDroppedFrames.AllInteractions", percent); if (ukm_reporter) { @@ -341,6 +373,10 @@ base::Optional<int> FrameSequenceMetrics::ThroughputData::ReportHistogram( } if (is_animation || is_interaction) { + TRACE_EVENT_INSTANT2("cc,benchmark", "PercentDroppedFrames.AllSequences", + TRACE_EVENT_SCOPE_THREAD, "frames_expected", + data.frames_expected, "frames_produced", + data.frames_produced); UMA_HISTOGRAM_PERCENTAGE( "Graphics.Smoothness.PercentDroppedFrames.AllSequences", percent); if (ukm_reporter) { @@ -368,4 +404,62 @@ base::Optional<int> FrameSequenceMetrics::ThroughputData::ReportHistogram( return percent; } +std::unique_ptr<base::trace_event::TracedValue> +FrameSequenceMetrics::ThroughputData::ToTracedValue( + const ThroughputData& impl, + const ThroughputData& main, + ThreadType effective_thread) { + auto dict = std::make_unique<base::trace_event::TracedValue>(); + if (effective_thread == ThreadType::kMain) { + dict->SetInteger("main-frames-produced", main.frames_produced); + dict->SetInteger("main-frames-expected", main.frames_expected); + } else { + dict->SetInteger("impl-frames-produced", impl.frames_produced); + dict->SetInteger("impl-frames-expected", impl.frames_expected); + } + return dict; +} + +FrameSequenceMetrics::TraceData::TraceData(FrameSequenceMetrics* m) + : metrics(m) { + TRACE_EVENT_CATEGORY_GROUP_ENABLED("cc,benchmark", &enabled); +} + +FrameSequenceMetrics::TraceData::~TraceData() = default; + +void FrameSequenceMetrics::TraceData::Terminate() { + if (!enabled || !trace_id) + return; + TRACE_EVENT_NESTABLE_ASYNC_END2( + "cc,benchmark", "FrameSequenceTracker", TRACE_ID_LOCAL(trace_id), "args", + ThroughputData::ToTracedValue(metrics->impl_throughput(), + metrics->main_throughput(), + metrics->GetEffectiveThread()), + "checkerboard", metrics->frames_checkerboarded()); + trace_id = nullptr; +} + +void FrameSequenceMetrics::TraceData::Advance(base::TimeTicks new_timestamp) { + if (!enabled) + return; + if (!trace_id) { + trace_id = this; + TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( + "cc,benchmark", "FrameSequenceTracker", TRACE_ID_LOCAL(trace_id), + this->last_timestamp, "name", + FrameSequenceTracker::GetFrameSequenceTrackerTypeName(metrics->type())); + } + // Use different names, because otherwise the trace-viewer shows the slices in + // the same color, and that makes it difficult to tell the traces apart from + // each other. + const char* trace_names[] = {"Frame", "Frame ", "Frame "}; + TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( + "cc,benchmark", trace_names[++this->frame_count % 3], + TRACE_ID_LOCAL(trace_id), this->last_timestamp); + TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( + "cc,benchmark", trace_names[this->frame_count % 3], + TRACE_ID_LOCAL(trace_id), new_timestamp); + this->last_timestamp = new_timestamp; +} + } // namespace cc diff --git a/chromium/cc/metrics/frame_sequence_metrics.h b/chromium/cc/metrics/frame_sequence_metrics.h index 0417899c3a9..3a77fc57775 100644 --- a/chromium/cc/metrics/frame_sequence_metrics.h +++ b/chromium/cc/metrics/frame_sequence_metrics.h @@ -5,6 +5,8 @@ #ifndef CC_METRICS_FRAME_SEQUENCE_METRICS_H_ #define CC_METRICS_FRAME_SEQUENCE_METRICS_H_ +#include <memory> + #include "base/callback.h" #include "base/optional.h" #include "base/trace_event/traced_value.h" @@ -44,7 +46,8 @@ class CC_EXPORT FrameSequenceMetrics { struct ThroughputData { static std::unique_ptr<base::trace_event::TracedValue> ToTracedValue( const ThroughputData& impl, - const ThroughputData& main); + const ThroughputData& main, + ThreadType effective_thred); // Returns the throughput in percent, a return value of base::nullopt // indicates that no throughput metric is reported. @@ -62,6 +65,13 @@ class CC_EXPORT FrameSequenceMetrics { #endif } + int DroppedFramePercent() const { + if (frames_expected == 0) + return 0; + return std::ceil(100 * (frames_expected - frames_produced) / + static_cast<double>(frames_expected)); + } + // Tracks the number of frames that were expected to be shown during this // frame-sequence. uint32_t frames_expected = 0; @@ -113,10 +123,31 @@ class CC_EXPORT FrameSequenceMetrics { return throughput_ukm_reporter_; } + // Must be called before destructor. + void ReportLeftoverData(); + + void AdoptTrace(FrameSequenceMetrics* adopt_from); + void AdvanceTrace(base::TimeTicks timestamp); + private: void ComputeAggregatedThroughput(); + const FrameSequenceTrackerType type_; + // Tracks some data to generate useful trace events. + struct TraceData { + explicit TraceData(FrameSequenceMetrics* metrics); + ~TraceData(); + FrameSequenceMetrics* metrics; + base::TimeTicks last_timestamp = base::TimeTicks::Now(); + int frame_count = 0; + bool enabled = false; + void* trace_id = nullptr; + + void Advance(base::TimeTicks new_timestamp); + void Terminate(); + } trace_data_{this}; + // Pointer to the reporter owned by the FrameSequenceTrackerCollection. ThroughputUkmReporter* const throughput_ukm_reporter_; diff --git a/chromium/cc/metrics/frame_sequence_metrics_unittest.cc b/chromium/cc/metrics/frame_sequence_metrics_unittest.cc index ae43da19a24..c2a1f76babb 100644 --- a/chromium/cc/metrics/frame_sequence_metrics_unittest.cc +++ b/chromium/cc/metrics/frame_sequence_metrics_unittest.cc @@ -6,6 +6,9 @@ #include "base/macros.h" #include "base/test/metrics/histogram_tester.h" +#include "cc/metrics/throughput_ukm_reporter.h" +#include "cc/trees/ukm_manager.h" +#include "components/ukm/test_ukm_recorder.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" @@ -28,6 +31,7 @@ TEST(FrameSequenceMetricsTest, AggregatedThroughputClearedAfterReport) { nullptr); first.impl_throughput().frames_expected = 200u; first.impl_throughput().frames_produced = 190u; + first.aggregated_throughput().frames_expected = 170u; first.aggregated_throughput().frames_produced = 150u; first.ReportMetrics(); @@ -35,6 +39,28 @@ TEST(FrameSequenceMetricsTest, AggregatedThroughputClearedAfterReport) { EXPECT_EQ(first.aggregated_throughput().frames_produced, 0u); } +// Test that ThroughputUkmReporter::ReportThroughputUkm isn't called for the +// kUniversal tracker. +TEST(FrameSequenceMetricsTest, UniversalNotReportUkmAtRenderer) { + auto recorder = std::make_unique<ukm::TestUkmRecorder>(); + auto ukm_manager = std::make_unique<UkmManager>(std::move(recorder)); + ThroughputUkmReporter reporter(ukm_manager.get()); + auto metric = std::make_unique<FrameSequenceMetrics>( + FrameSequenceTrackerType::kUniversal, &reporter); + + metric->impl_throughput().frames_expected = 200u; + metric->impl_throughput().frames_produced = 190u; + metric->aggregated_throughput().frames_expected = 170u; + metric->aggregated_throughput().frames_produced = 150u; + metric->ReportMetrics(); + + // The corresponding |samples_to_next_event_| element is 0 if the + // ReportThroughputUkm isn't called. + EXPECT_EQ(reporter.GetSamplesToNextEventForTesting( + static_cast<int>(FrameSequenceTrackerType::kUniversal)), + 1u); +} + TEST(FrameSequenceMetricsTest, MergeMetrics) { // Create a metric with only a small number of frames. It shouldn't report any // metrics. diff --git a/chromium/cc/metrics/frame_sequence_tracker.cc b/chromium/cc/metrics/frame_sequence_tracker.cc index f1a1fd9b995..dec83686b65 100644 --- a/chromium/cc/metrics/frame_sequence_tracker.cc +++ b/chromium/cc/metrics/frame_sequence_tracker.cc @@ -4,7 +4,13 @@ #include "cc/metrics/frame_sequence_tracker.h" +#include <algorithm> +#include <memory> +#include <string> +#include <utility> + #include "base/bind.h" +#include "base/logging.h" #include "base/metrics/histogram.h" #include "base/metrics/histogram_macros.h" #include "base/trace_event/trace_event.h" @@ -27,6 +33,8 @@ namespace cc { +using ThreadType = FrameSequenceMetrics::ThreadType; + // In the |TRACKER_TRACE_STREAM|, we mod the numbers such as frame sequence // number, or frame token, such that the debug string is not too long. constexpr int kDebugStrMod = 1000; @@ -63,9 +71,9 @@ FrameSequenceTracker::FrameSequenceTracker( FrameSequenceTrackerType type, ThroughputUkmReporter* throughput_ukm_reporter) : custom_sequence_id_(-1), - metrics_(std::make_unique<FrameSequenceMetrics>(type, - throughput_ukm_reporter)), - trace_data_(metrics_.get()) { + metrics_( + std::make_unique<FrameSequenceMetrics>(type, + throughput_ukm_reporter)) { DCHECK_LT(type, FrameSequenceTrackerType::kMaxType); DCHECK(type != FrameSequenceTrackerType::kCustom); } @@ -76,13 +84,14 @@ FrameSequenceTracker::FrameSequenceTracker( : custom_sequence_id_(custom_sequence_id), metrics_(std::make_unique<FrameSequenceMetrics>( FrameSequenceTrackerType::kCustom, - /*ukm_reporter=*/nullptr)), - trace_data_(metrics_.get()) { + /*ukm_reporter=*/nullptr)) { DCHECK_GT(custom_sequence_id_, 0); metrics_->SetCustomReporter(std::move(custom_reporter)); } -FrameSequenceTracker::~FrameSequenceTracker() = default; +FrameSequenceTracker::~FrameSequenceTracker() { + CleanUp(); +} void FrameSequenceTracker::ScheduleTerminate() { // If the last frame has ended and there is no frame awaiting presentation, @@ -126,6 +135,8 @@ void FrameSequenceTracker::ReportBeginImplFrame( args.frame_id.sequence_number); impl_throughput().frames_expected += begin_impl_frame_data_.previous_sequence_delta; + aggregated_throughput().frames_expected += + begin_impl_frame_data_.previous_sequence_delta; #if DCHECK_IS_ON() ++impl_throughput().frames_received; #endif @@ -363,6 +374,8 @@ void FrameSequenceTracker::ReportFrameEnd( NOTREACHED() << TRACKER_DCHECK_MSG; #endif begin_impl_frame_data_.previous_sequence = 0; + if (!IsExpectingMainFrame()) + --aggregated_throughput().frames_expected; } // last_submitted_frame_ == 0 means the last impl frame has been presented. if (termination_status_ == TerminationStatus::kScheduledForTermination && @@ -423,15 +436,17 @@ void FrameSequenceTracker::ReportFramePresented( uint32_t impl_frames_produced = 0; uint32_t main_frames_produced = 0; - trace_data_.Advance(feedback.timestamp); - const bool was_presented = !feedback.timestamp.is_null(); + const bool was_presented = !feedback.failed(); if (was_presented && submitted_frame_since_last_presentation) { DCHECK_LT(impl_throughput().frames_produced, impl_throughput().frames_expected) << TRACKER_DCHECK_MSG; ++impl_throughput().frames_produced; ++impl_frames_produced; + if (metrics()->GetEffectiveThread() == ThreadType::kCompositor) { + metrics()->AdvanceTrace(feedback.timestamp); + } } if (was_presented) { @@ -448,6 +463,9 @@ void FrameSequenceTracker::ReportFramePresented( << TRACKER_DCHECK_MSG; ++main_throughput().frames_produced; ++main_frames_produced; + if (metrics()->GetEffectiveThread() == ThreadType::kMain) { + metrics()->AdvanceTrace(feedback.timestamp); + } } if (impl_frames_produced > 0) { @@ -647,16 +665,11 @@ bool FrameSequenceTracker::ShouldIgnoreSequence( return sequence_number != begin_impl_frame_data_.previous_sequence; } -std::unique_ptr<base::trace_event::TracedValue> -FrameSequenceMetrics::ThroughputData::ToTracedValue( - const ThroughputData& impl, - const ThroughputData& main) { - auto dict = std::make_unique<base::trace_event::TracedValue>(); - dict->SetInteger("impl-frames-produced", impl.frames_produced); - dict->SetInteger("impl-frames-expected", impl.frames_expected); - dict->SetInteger("main-frames-produced", main.frames_produced); - dict->SetInteger("main-frames-expected", main.frames_expected); - return dict; +bool FrameSequenceTracker::IsExpectingMainFrame() const { + bool last_main_not_processed = + begin_main_frame_data_.previous_sequence != 0 && + begin_main_frame_data_.previous_sequence != last_processed_main_sequence_; + return !main_frames_.empty() || last_main_not_processed; } bool FrameSequenceTracker::ShouldReportMetricsNow( @@ -675,22 +688,12 @@ std::unique_ptr<FrameSequenceMetrics> FrameSequenceTracker::TakeMetrics() { return std::move(metrics_); } +void FrameSequenceTracker::CleanUp() { + if (metrics_) + metrics_->ReportLeftoverData(); +} + FrameSequenceTracker::CheckerboardingData::CheckerboardingData() = default; FrameSequenceTracker::CheckerboardingData::~CheckerboardingData() = default; -FrameSequenceTracker::TraceData::TraceData(const void* id) : trace_id(id) {} -void FrameSequenceTracker::TraceData::Advance(base::TimeTicks new_timestamp) { - // Use different names, because otherwise the trace-viewer shows the slices in - // the same color, and that makes it difficult to tell the traces apart from - // each other. - const char* trace_names[] = {"Frame", "Frame ", "Frame "}; - TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( - "cc,benchmark", trace_names[++this->frame_count % 3], - TRACE_ID_LOCAL(this->trace_id), this->last_timestamp); - TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( - "cc,benchmark", trace_names[this->frame_count % 3], - TRACE_ID_LOCAL(this->trace_id), new_timestamp); - this->last_timestamp = new_timestamp; -} - } // namespace cc diff --git a/chromium/cc/metrics/frame_sequence_tracker.h b/chromium/cc/metrics/frame_sequence_tracker.h index 680b2a85ad9..86deb91b3bd 100644 --- a/chromium/cc/metrics/frame_sequence_tracker.h +++ b/chromium/cc/metrics/frame_sequence_tracker.h @@ -5,6 +5,9 @@ #ifndef CC_METRICS_FRAME_SEQUENCE_TRACKER_H_ #define CC_METRICS_FRAME_SEQUENCE_TRACKER_H_ +#include <memory> +#include <sstream> + #include "base/containers/circular_deque.h" #include "base/containers/flat_map.h" #include "base/containers/flat_set.h" @@ -101,6 +104,10 @@ class CC_EXPORT FrameSequenceTracker { std::unique_ptr<FrameSequenceMetrics> TakeMetrics(); + // Called by the destructor of FrameSequenceTrackerCollection, asking its + // |metrics_| to report. + void CleanUp(); + private: friend class FrameSequenceTrackerCollection; friend class FrameSequenceTrackerTest; @@ -158,6 +165,8 @@ class CC_EXPORT FrameSequenceTracker { bool ShouldIgnoreSequence(uint64_t sequence_number) const; + bool IsExpectingMainFrame() const; + const int custom_sequence_id_; TerminationStatus termination_status_ = TerminationStatus::kActive; @@ -247,16 +256,6 @@ class CC_EXPORT FrameSequenceTracker { // TODO(xidachen): remove this one. uint64_t current_begin_main_sequence_ = 0; - // Tracks some data to generate useful trace events. - struct TraceData { - explicit TraceData(const void* trace_id); - const void* trace_id; - base::TimeTicks last_timestamp = base::TimeTicks::Now(); - int frame_count = 0; - - void Advance(base::TimeTicks new_timestamp); - } trace_data_; - // True when an impl-impl is not ended. A tracker is ready for termination // only when the last impl-frame is ended (ReportFrameEnd). bool is_inside_frame_ = false; diff --git a/chromium/cc/metrics/frame_sequence_tracker_collection.cc b/chromium/cc/metrics/frame_sequence_tracker_collection.cc index 8dd78ca0ccd..1efd3a37159 100644 --- a/chromium/cc/metrics/frame_sequence_tracker_collection.cc +++ b/chromium/cc/metrics/frame_sequence_tracker_collection.cc @@ -11,6 +11,18 @@ namespace cc { +namespace { + +using ThreadType = FrameSequenceMetrics::ThreadType; + +bool IsScrollType(FrameSequenceTrackerType type) { + return type == FrameSequenceTrackerType::kTouchScroll || + type == FrameSequenceTrackerType::kWheelScroll || + type == FrameSequenceTrackerType::kScrollbarScroll; +} + +} // namespace + FrameSequenceTrackerCollection::FrameSequenceTrackerCollection( bool is_single_threaded, CompositorFrameReportingController* compositor_frame_reporting_controller) @@ -19,42 +31,86 @@ FrameSequenceTrackerCollection::FrameSequenceTrackerCollection( compositor_frame_reporting_controller) {} FrameSequenceTrackerCollection::~FrameSequenceTrackerCollection() { + CleanUp(); frame_trackers_.clear(); removal_trackers_.clear(); } -FrameSequenceMetrics* FrameSequenceTrackerCollection::StartSequence( - FrameSequenceTrackerType type) { +FrameSequenceTracker* FrameSequenceTrackerCollection::StartSequenceInternal( + FrameSequenceTrackerType type, + FrameSequenceMetrics::ThreadType scrolling_thread) { DCHECK_NE(FrameSequenceTrackerType::kCustom, type); - if (is_single_threaded_) return nullptr; - if (frame_trackers_.contains(type)) - return frame_trackers_[type]->metrics(); + auto key = std::make_pair(type, scrolling_thread); + if (frame_trackers_.contains(key)) + return frame_trackers_[key].get(); + auto tracker = base::WrapUnique( new FrameSequenceTracker(type, throughput_ukm_reporter_.get())); - frame_trackers_[type] = std::move(tracker); + frame_trackers_[key] = std::move(tracker); if (compositor_frame_reporting_controller_) compositor_frame_reporting_controller_->AddActiveTracker(type); - return frame_trackers_[type]->metrics(); + + auto* metrics = frame_trackers_[key]->metrics(); + if (accumulated_metrics_.contains(key)) { + metrics->AdoptTrace(accumulated_metrics_[key].get()); + } + if (IsScrollType(type)) { + DCHECK_NE(scrolling_thread, ThreadType::kUnknown); + metrics->SetScrollingThread(scrolling_thread); + } + return frame_trackers_[key].get(); +} + +FrameSequenceTracker* FrameSequenceTrackerCollection::StartSequence( + FrameSequenceTrackerType type) { + DCHECK(!IsScrollType(type)); + return StartSequenceInternal(type, ThreadType::kUnknown); +} + +FrameSequenceTracker* FrameSequenceTrackerCollection::StartScrollSequence( + FrameSequenceTrackerType type, + FrameSequenceMetrics::ThreadType scrolling_thread) { + DCHECK(IsScrollType(type)); + return StartSequenceInternal(type, scrolling_thread); +} + +void FrameSequenceTrackerCollection::CleanUp() { + for (auto& tracker : frame_trackers_) + tracker.second->CleanUp(); + for (auto& tracker : custom_frame_trackers_) + tracker.second->CleanUp(); + for (auto& tracker : removal_trackers_) + tracker->CleanUp(); + for (auto& metric : accumulated_metrics_) + metric.second->ReportLeftoverData(); + throughput_ukm_reporter_ = nullptr; } void FrameSequenceTrackerCollection::StopSequence( FrameSequenceTrackerType type) { DCHECK_NE(FrameSequenceTrackerType::kCustom, type); - if (!frame_trackers_.contains(type)) + auto key = std::make_pair(type, ThreadType::kUnknown); + if (IsScrollType(type)) { + key = std::make_pair(type, ThreadType::kCompositor); + if (!frame_trackers_.contains(key)) + key = std::make_pair(type, ThreadType::kMain); + } + + if (!frame_trackers_.contains(key)) return; std::unique_ptr<FrameSequenceTracker> tracker = - std::move(frame_trackers_[type]); + std::move(frame_trackers_[key]); if (compositor_frame_reporting_controller_) compositor_frame_reporting_controller_->RemoveActiveTracker( tracker->type()); - frame_trackers_.erase(type); + frame_trackers_.erase(key); tracker->ScheduleTerminate(); removal_trackers_.push_back(std::move(tracker)); DestroyTrackers(); @@ -193,10 +249,42 @@ void FrameSequenceTrackerCollection::NotifyFramePresented( tracker.second->ReportFramePresented(frame_token, feedback); for (auto& tracker : custom_frame_trackers_) tracker.second->ReportFramePresented(frame_token, feedback); - for (auto& tracker : removal_trackers_) tracker->ReportFramePresented(frame_token, feedback); + DestroyTrackers(); +} + +bool FrameSequenceTrackerCollection::HasThroughputData() const { + return throughput_ukm_reporter_ && + throughput_ukm_reporter_->HasThroughputData(); +} + +int FrameSequenceTrackerCollection::TakeLastAggregatedPercent() { + DCHECK(throughput_ukm_reporter_); + return throughput_ukm_reporter_->TakeLastAggregatedPercent(); +} + +int FrameSequenceTrackerCollection::TakeLastImplPercent() { + DCHECK(throughput_ukm_reporter_); + return throughput_ukm_reporter_->TakeLastImplPercent(); +} + +base::Optional<int> FrameSequenceTrackerCollection::TakeLastMainPercent() { + DCHECK(throughput_ukm_reporter_); + return throughput_ukm_reporter_->TakeLastMainPercent(); +} + +void FrameSequenceTrackerCollection::ComputeUniversalThroughputForTesting() { + DCHECK(throughput_ukm_reporter_); + const auto type = FrameSequenceTrackerType::kUniversal; + auto key = std::make_pair(type, ThreadType::kUnknown); + DCHECK(frame_trackers_.contains(key)); + throughput_ukm_reporter_->ComputeUniversalThroughput( + frame_trackers_[key]->metrics()); +} + +void FrameSequenceTrackerCollection::DestroyTrackers() { for (auto& tracker : removal_trackers_) { if (tracker->termination_status() == FrameSequenceTracker::TerminationStatus::kReadyForTermination) { @@ -209,9 +297,10 @@ void FrameSequenceTrackerCollection::NotifyFramePresented( // For kCustom typed trackers, |metrics| invokes AddCustomTrackerResult // on its destruction, which add its data to |custom_tracker_results_| // to be picked up by caller. - auto metrics = tracker->TakeMetrics(); - if (metrics->type() == FrameSequenceTrackerType::kCustom) + if (tracker->metrics() && + tracker->type() == FrameSequenceTrackerType::kCustom) continue; + auto metrics = tracker->TakeMetrics(); auto key = std::make_pair(metrics->type(), metrics->GetEffectiveThread()); if (accumulated_metrics_.contains(key)) { @@ -220,24 +309,17 @@ void FrameSequenceTrackerCollection::NotifyFramePresented( } if (metrics->HasEnoughDataForReporting()) { - if (metrics->type() == FrameSequenceTrackerType::kUniversal) { - uint32_t frames_expected = metrics->impl_throughput().frames_expected; - uint32_t frames_produced = - metrics->aggregated_throughput().frames_produced; - current_universal_throughput_ = std::floor( - 100 * frames_produced / static_cast<float>(frames_expected)); - } + // Do this before ReportMetrics() which clears the throughput data. + if (metrics->type() == FrameSequenceTrackerType::kUniversal) + throughput_ukm_reporter_->ComputeUniversalThroughput(metrics.get()); metrics->ReportMetrics(); } - if (metrics->HasDataLeftForReporting()) + if (metrics->HasDataLeftForReporting()) { accumulated_metrics_[key] = std::move(metrics); + } } } - DestroyTrackers(); -} - -void FrameSequenceTrackerCollection::DestroyTrackers() { base::EraseIf( removal_trackers_, [](const std::unique_ptr<FrameSequenceTracker>& tracker) { @@ -248,28 +330,40 @@ void FrameSequenceTrackerCollection::DestroyTrackers() { void FrameSequenceTrackerCollection::RecreateTrackers( const viz::BeginFrameArgs& args) { - std::vector<FrameSequenceTrackerType> recreate_trackers; + std::vector<std::pair<FrameSequenceTrackerType, ThreadType>> + recreate_trackers; for (const auto& tracker : frame_trackers_) { if (tracker.second->ShouldReportMetricsNow(args)) recreate_trackers.push_back(tracker.first); } - for (const auto& tracker_type : recreate_trackers) { + for (const auto& key : recreate_trackers) { + DCHECK(frame_trackers_[key]); + auto tracker_type = key.first; + ThreadType thread_type = key.second; + // StopSequence put the tracker in the |removal_trackers_|, which will // report its throughput data when its frame is presented. StopSequence(tracker_type); + // The frame sequence is still active, so create a new tracker to keep // tracking this sequence. - StartSequence(tracker_type); + if (thread_type != FrameSequenceMetrics::ThreadType::kUnknown) { + DCHECK(IsScrollType(tracker_type)); + StartScrollSequence(tracker_type, thread_type); + } else { + StartSequence(tracker_type); + } } } ActiveFrameSequenceTrackers FrameSequenceTrackerCollection::FrameSequenceTrackerActiveTypes() { ActiveFrameSequenceTrackers encoded_types = 0; - for (const auto& tracker : frame_trackers_) { + for (const auto& key : frame_trackers_) { + auto thread_type = key.first.first; encoded_types |= static_cast<ActiveFrameSequenceTrackers>( - 1 << static_cast<unsigned>(tracker.first)); + 1 << static_cast<unsigned>(thread_type)); } return encoded_types; } @@ -281,13 +375,6 @@ FrameSequenceTrackerCollection::TakeCustomTrackerResults() { return results; } -FrameSequenceTracker* FrameSequenceTrackerCollection::GetTrackerForTesting( - FrameSequenceTrackerType type) { - if (!frame_trackers_.contains(type)) - return nullptr; - return frame_trackers_[type].get(); -} - FrameSequenceTracker* FrameSequenceTrackerCollection::GetRemovalTrackerForTesting( FrameSequenceTrackerType type) { diff --git a/chromium/cc/metrics/frame_sequence_tracker_collection.h b/chromium/cc/metrics/frame_sequence_tracker_collection.h index 9eaf1efb6b2..0fecfce7895 100644 --- a/chromium/cc/metrics/frame_sequence_tracker_collection.h +++ b/chromium/cc/metrics/frame_sequence_tracker_collection.h @@ -6,6 +6,8 @@ #define CC_METRICS_FRAME_SEQUENCE_TRACKER_COLLECTION_H_ #include <memory> +#include <utility> +#include <vector> #include "base/containers/flat_map.h" #include "base/optional.h" @@ -47,8 +49,12 @@ class CC_EXPORT FrameSequenceTrackerCollection { FrameSequenceTrackerCollection& operator=( const FrameSequenceTrackerCollection&) = delete; - // Creates a tracker for the specified sequence-type. - FrameSequenceMetrics* StartSequence(FrameSequenceTrackerType type); + // Creates a new tracker for the specified sequence-type if one doesn't + // already exist. Returns the associated FrameSequenceTracker instance. + FrameSequenceTracker* StartSequence(FrameSequenceTrackerType type); + FrameSequenceTracker* StartScrollSequence( + FrameSequenceTrackerType type, + FrameSequenceMetrics::ThreadType scrolling_thread); // Schedules |tracker| for destruction. This is preferred instead of outright // desrtruction of the tracker, since this ensures that the actual tracker @@ -103,23 +109,35 @@ class CC_EXPORT FrameSequenceTrackerCollection { // Reports the accumulated kCustom tracker results and clears it. CustomTrackerResults TakeCustomTrackerResults(); - FrameSequenceTracker* GetTrackerForTesting(FrameSequenceTrackerType type); FrameSequenceTracker* GetRemovalTrackerForTesting( FrameSequenceTrackerType type); void SetUkmManager(UkmManager* manager); - base::Optional<int> current_universal_throughput() { - return current_universal_throughput_; - } + // These methods directly calls corresponding APIs in ThroughputUkmReporter, + // please refer to the ThroughputUkmReporter for details. + bool HasThroughputData() const; + int TakeLastAggregatedPercent(); + int TakeLastImplPercent(); + base::Optional<int> TakeLastMainPercent(); + + void ComputeUniversalThroughputForTesting(); private: friend class FrameSequenceTrackerTest; + FrameSequenceTracker* StartSequenceInternal( + FrameSequenceTrackerType type, + FrameSequenceMetrics::ThreadType scrolling_thread); + void RecreateTrackers(const viz::BeginFrameArgs& args); // Destroy the trackers that are ready to be terminated. void DestroyTrackers(); + // Ask all trackers to report their metrics if there is any, must be the first + // thing in the destructor. + void CleanUp(); + // Adds collected metrics data for |custom_sequence_id| to be picked up via // TakeCustomTrackerResults() below. void AddCustomTrackerResult( @@ -127,9 +145,19 @@ class CC_EXPORT FrameSequenceTrackerCollection { FrameSequenceMetrics::ThroughputData throughput_data); const bool is_single_threaded_; + // The reporter takes throughput data and connect to UkmManager to report it. + // Note: this has to be before the frame_trackers_. The reason is that a + // FrameSequenceTracker owners a FrameSequenceMetrics, so the destructor of + // the former calls the destructor of the later. FrameSequenceMetrics's + // destructor calls its ReportMetrics() which requires + // |throughput_ukm_reporter_| to be alive. So putting it before + // |frame_trackers_| to ensure that it is destroyed after the tracker. + std::unique_ptr<ThroughputUkmReporter> throughput_ukm_reporter_; + // The callsite can use the type to manipulate the tracker. - base::flat_map<FrameSequenceTrackerType, - std::unique_ptr<FrameSequenceTracker>> + base::flat_map< + std::pair<FrameSequenceTrackerType, FrameSequenceMetrics::ThreadType>, + std::unique_ptr<FrameSequenceTracker>> frame_trackers_; // Custom trackers are keyed by a custom sequence id. @@ -141,14 +169,10 @@ class CC_EXPORT FrameSequenceTrackerCollection { CompositorFrameReportingController* const compositor_frame_reporting_controller_; - // The reporter takes throughput data and connect to UkmManager to report it. - std::unique_ptr<ThroughputUkmReporter> throughput_ukm_reporter_; - base::flat_map< std::pair<FrameSequenceTrackerType, FrameSequenceMetrics::ThreadType>, std::unique_ptr<FrameSequenceMetrics>> accumulated_metrics_; - base::Optional<int> current_universal_throughput_; }; } // namespace cc diff --git a/chromium/cc/metrics/frame_sequence_tracker_unittest.cc b/chromium/cc/metrics/frame_sequence_tracker_unittest.cc index 2a6b8cd2b82..963cf1045f4 100644 --- a/chromium/cc/metrics/frame_sequence_tracker_unittest.cc +++ b/chromium/cc/metrics/frame_sequence_tracker_unittest.cc @@ -8,6 +8,9 @@ #include "base/test/metrics/histogram_tester.h" #include "cc/metrics/compositor_frame_reporting_controller.h" #include "cc/metrics/frame_sequence_tracker_collection.h" +#include "cc/metrics/throughput_ukm_reporter.h" +#include "cc/trees/ukm_manager.h" +#include "components/ukm/test_ukm_recorder.h" #include "components/viz/common/frame_sinks/begin_frame_args.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" @@ -40,16 +43,16 @@ class FrameSequenceTrackerTest : public testing::Test { /*should_report_metrics=*/true)), collection_(/*is_single_threaded=*/false, compositor_frame_reporting_controller_.get()) { - collection_.StartSequence(FrameSequenceTrackerType::kTouchScroll); - tracker_ = collection_.GetTrackerForTesting( - FrameSequenceTrackerType::kTouchScroll); + tracker_ = collection_.StartScrollSequence( + FrameSequenceTrackerType::kTouchScroll, + FrameSequenceMetrics::ThreadType::kCompositor); } ~FrameSequenceTrackerTest() override = default; - void CreateNewTracker() { - collection_.StartSequence(FrameSequenceTrackerType::kTouchScroll); - tracker_ = collection_.GetTrackerForTesting( - FrameSequenceTrackerType::kTouchScroll); + void CreateNewTracker(FrameSequenceMetrics::ThreadType thread_type = + FrameSequenceMetrics::ThreadType::kCompositor) { + tracker_ = collection_.StartScrollSequence( + FrameSequenceTrackerType::kTouchScroll, thread_type); } viz::BeginFrameArgs CreateBeginFrameArgs( @@ -100,7 +103,15 @@ class FrameSequenceTrackerTest : public testing::Test { // Check whether a type of tracker exists in |frame_trackers_| or not. bool TrackerExists(FrameSequenceTrackerType type) const { - return collection_.frame_trackers_.contains(type); + auto key = std::make_pair(type, FrameSequenceMetrics::ThreadType::kUnknown); + if (type == FrameSequenceTrackerType::kTouchScroll || + type == FrameSequenceTrackerType::kWheelScroll || + type == FrameSequenceTrackerType::kScrollbarScroll) { + key = std::make_pair(type, FrameSequenceMetrics::ThreadType::kCompositor); + if (!collection_.frame_trackers_.contains(key)) + key = std::make_pair(type, FrameSequenceMetrics::ThreadType::kMain); + } + return collection_.frame_trackers_.contains(key); } bool RemovalTrackerExists(unsigned index, @@ -254,14 +265,29 @@ class FrameSequenceTrackerTest : public testing::Test { return tracker_->ignored_frame_tokens_; } + FrameSequenceMetrics::ThroughputData& ImplThroughput( + FrameSequenceTracker* tracker) const { + return tracker->impl_throughput(); + } + FrameSequenceMetrics::ThroughputData& ImplThroughput() const { return tracker_->impl_throughput(); } + FrameSequenceMetrics::ThroughputData& MainThroughput( + FrameSequenceTracker* tracker) const { + return tracker->main_throughput(); + } + FrameSequenceMetrics::ThroughputData& MainThroughput() const { return tracker_->main_throughput(); } + FrameSequenceMetrics::ThroughputData& AggregatedThroughput( + FrameSequenceTracker* tracker) const { + return tracker->aggregated_throughput(); + } + FrameSequenceMetrics::ThroughputData& AggregatedThroughput() const { return tracker_->aggregated_throughput(); } @@ -464,8 +490,6 @@ TEST_F(FrameSequenceTrackerTest, ReportMetrics) { 1u); histogram_tester.ExpectTotalCount( "Graphics.Smoothness.PercentDroppedFrames.MainThread.TouchScroll", 0u); - histogram_tester.ExpectTotalCount( - "Graphics.Smoothness.PercentDroppedFrames.SlowerThread.TouchScroll", 1u); // Test that both are reported. ImplThroughput().frames_expected = 100u; @@ -478,8 +502,6 @@ TEST_F(FrameSequenceTrackerTest, ReportMetrics) { 2u); histogram_tester.ExpectTotalCount( "Graphics.Smoothness.PercentDroppedFrames.MainThread.TouchScroll", 1u); - histogram_tester.ExpectTotalCount( - "Graphics.Smoothness.PercentDroppedFrames.SlowerThread.TouchScroll", 2u); // Test that none is reported. MainThroughput().frames_expected = 2u; @@ -492,8 +514,6 @@ TEST_F(FrameSequenceTrackerTest, ReportMetrics) { 2u); histogram_tester.ExpectTotalCount( "Graphics.Smoothness.PercentDroppedFrames.MainThread.TouchScroll", 1u); - histogram_tester.ExpectTotalCount( - "Graphics.Smoothness.PercentDroppedFrames.SlowerThread.TouchScroll", 2u); // Test the case where compositor and main thread have the same throughput. ImplThroughput().frames_expected = 120u; @@ -506,8 +526,6 @@ TEST_F(FrameSequenceTrackerTest, ReportMetrics) { 3u); histogram_tester.ExpectTotalCount( "Graphics.Smoothness.PercentDroppedFrames.MainThread.TouchScroll", 2u); - histogram_tester.ExpectTotalCount( - "Graphics.Smoothness.PercentDroppedFrames.SlowerThread.TouchScroll", 3u); } TEST_F(FrameSequenceTrackerTest, ReportMetricsAtFixedInterval) { @@ -638,9 +656,6 @@ TEST_F(FrameSequenceTrackerTest, BeginMainFrameSubmit) { } TEST_F(FrameSequenceTrackerTest, ScrollingThreadMetricCompositorThread) { - tracker_->metrics()->SetScrollingThread( - FrameSequenceMetrics::ThreadType::kCompositor); - // Start with a bunch of frames so that the metric does get reported at the // end of the test. ImplThroughput().frames_expected = 100u; @@ -659,8 +674,7 @@ TEST_F(FrameSequenceTrackerTest, ScrollingThreadMetricCompositorThread) { } TEST_F(FrameSequenceTrackerTest, ScrollingThreadMetricMainThread) { - tracker_->metrics()->SetScrollingThread( - FrameSequenceMetrics::ThreadType::kMain); + CreateNewTracker(FrameSequenceMetrics::ThreadType::kMain); // Start with a bunch of frames so that the metric does get reported at the // end of the test. @@ -1104,8 +1118,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame2) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1132,8 +1146,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame3) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1160,8 +1174,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame4) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1229,8 +1243,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame7) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1257,8 +1271,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame8) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1285,8 +1299,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame9) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1346,8 +1360,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame12) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1374,8 +1388,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame13) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1395,8 +1409,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame14) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1430,8 +1444,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame15) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1458,8 +1472,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame16) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1486,8 +1500,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame17) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1515,8 +1529,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame18) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1543,8 +1557,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame19) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1571,8 +1585,8 @@ TEST_F(FrameSequenceTrackerTest, TrackLastImplFrame20) { EXPECT_EQ(NumberOfRemovalTrackers(), 0u); std::string metric = "Graphics.Smoothness.FrameSequenceLength.TouchScroll"; - // Both impl and slower threads reports 101 frames expected. - EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 2); + // Impl thread reports 101 frames expected. + EXPECT_EQ(histogram_tester.GetBucketCount(metric, 101), 1); // The main thread reports 0 frames expected. EXPECT_EQ(histogram_tester.GetBucketCount(metric, 0), 1); metric = @@ -1851,7 +1865,8 @@ TEST_F(FrameSequenceTrackerTest, MainThreadPresentWithNullTimeStamp) { const char sequence[] = "b(1)B(0,1)E(1)s(1)S(1)e(1,1)"; GenerateSequence(sequence); collection_.NotifyFramePresented( - 1, {base::TimeTicks(), viz::BeginFrameArgs::DefaultInterval(), 0}); + 1, {base::TimeTicks(), viz::BeginFrameArgs::DefaultInterval(), + gfx::PresentationFeedback::kFailure}); EXPECT_EQ(MainThroughput().frames_expected, 1u); // No presentation, no main frame produced. EXPECT_EQ(MainThroughput().frames_produced, 0u); @@ -1869,6 +1884,29 @@ TEST_F(FrameSequenceTrackerTest, TrackerTypeEncoding) { EXPECT_EQ(active_encoded, 16); // 1 << 4 } +TEST_F(FrameSequenceTrackerTest, UniversalTrackerSubmitThroughput) { + auto recorder = std::make_unique<ukm::TestUkmRecorder>(); + auto ukm_manager = std::make_unique<UkmManager>(std::move(recorder)); + + collection_.ClearAll(); + collection_.SetUkmManager(ukm_manager.get()); + auto* tracker = + collection_.StartSequence(FrameSequenceTrackerType::kUniversal); + ImplThroughput(tracker).frames_expected = 200u; + ImplThroughput(tracker).frames_produced = 190u; + MainThroughput(tracker).frames_expected = 100u; + MainThroughput(tracker).frames_produced = 50u; + AggregatedThroughput(tracker).frames_expected = 200u; + AggregatedThroughput(tracker).frames_produced = 150u; + + collection_.ComputeUniversalThroughputForTesting(); + DCHECK(collection_.HasThroughputData()); + EXPECT_EQ(collection_.TakeLastAggregatedPercent(), 25); + EXPECT_EQ(collection_.TakeLastImplPercent(), 5); + EXPECT_EQ(collection_.TakeLastMainPercent().value(), 50); + EXPECT_FALSE(collection_.HasThroughputData()); +} + TEST_F(FrameSequenceTrackerTest, CustomTrackers) { // Start custom tracker 1. collection_.StartCustomSequence(1); @@ -1918,4 +1956,104 @@ TEST_F(FrameSequenceTrackerTest, CustomTrackers) { EXPECT_EQ(1u, results[3].frames_expected); } +TEST_F(FrameSequenceTrackerTest, MergeTrackers) { + // Generate two sequences of scrolls: first with only 1 frame, and then with + // 99 frames. Verify that the two scrolls are merged to report a single + // metric. + base::HistogramTester histogram_tester; + const char first_sequence[] = "b(1)s(1)e(1,0)P(1)"; + GenerateSequence(first_sequence); + EXPECT_EQ(ImplThroughput().frames_expected, 1u); + EXPECT_EQ(ImplThroughput().frames_produced, 1u); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + + const char metric[] = + "Graphics.Smoothness.PercentDroppedFrames.CompositorThread.TouchScroll"; + histogram_tester.ExpectTotalCount(metric, 0u); + EXPECT_FALSE(TrackerExists(FrameSequenceTrackerType::kTouchScroll)); + + CreateNewTracker(); + const char second_sequence[] = "b(2)s(2)e(2,0)P(2)b(100)s(3)e(100,0)P(3)"; + GenerateSequence(second_sequence); + EXPECT_EQ(ImplThroughput().frames_expected, 99u); + EXPECT_EQ(ImplThroughput().frames_produced, 2u); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + EXPECT_FALSE(TrackerExists(FrameSequenceTrackerType::kTouchScroll)); + histogram_tester.ExpectTotalCount(metric, 1u); + EXPECT_THAT(histogram_tester.GetAllSamples(metric), + testing::ElementsAre(base::Bucket(97, 1))); +} + +TEST_F(FrameSequenceTrackerTest, MergeTrackersPresentAfterStopSequence) { + // Generate two sequences of scrolls: first with only 1 frame, and then with + // 99 frames. Verify that the two scrolls are merged to report a single + // metric. For the second sequence, the last frame is presented after the + // sequence ends. + base::HistogramTester histogram_tester; + const char first_sequence[] = "b(1)s(1)e(1,0)P(1)"; + GenerateSequence(first_sequence); + EXPECT_EQ(ImplThroughput().frames_expected, 1u); + EXPECT_EQ(ImplThroughput().frames_produced, 1u); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + + const char metric[] = + "Graphics.Smoothness.PercentDroppedFrames.CompositorThread.TouchScroll"; + histogram_tester.ExpectTotalCount(metric, 0u); + EXPECT_FALSE(TrackerExists(FrameSequenceTrackerType::kTouchScroll)); + + CreateNewTracker(); + const char second_sequence[] = "b(2)s(2)e(2,0)P(2)b(100)s(3)e(100,0)"; + GenerateSequence(second_sequence); + EXPECT_EQ(ImplThroughput().frames_expected, 99u); + EXPECT_EQ(ImplThroughput().frames_produced, 1u); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + GenerateSequence("P(3)"); + histogram_tester.ExpectTotalCount(metric, 1u); + EXPECT_THAT(histogram_tester.GetAllSamples(metric), + testing::ElementsAre(base::Bucket(97, 1))); +} + +TEST_F(FrameSequenceTrackerTest, MergeTrackersScrollOnSameThread) { + // Do a short scroll on the compositor thread, then do another short scroll on + // the compositor thread. Make sure these are merged. + base::HistogramTester histogram_tester; + const char first_sequence[] = "b(1)s(1)e(1,0)P(1)b(80)s(2)e(80,0)P(2)"; + GenerateSequence(first_sequence); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + + CreateNewTracker(FrameSequenceMetrics::ThreadType::kCompositor); + const char second_sequence[] = "b(81)s(3)e(81,0)P(3)b(101)s(4)e(101,0)P(4)"; + GenerateSequence(second_sequence); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + + const char comp_metric[] = + "Graphics.Smoothness.PercentDroppedFrames.CompositorThread.TouchScroll"; + const char main_metric[] = + "Graphics.Smoothness.PercentDroppedFrames.MainThread.TouchScroll"; + histogram_tester.ExpectTotalCount(comp_metric, 1u); + histogram_tester.ExpectTotalCount(main_metric, 0u); +} + +TEST_F(FrameSequenceTrackerTest, MergeTrackersScrollOnDifferentThreads) { + // Do a short scroll on the compositor thread, then do another short scroll on + // the main-thread. Make sure these are not merged. + base::HistogramTester histogram_tester; + const char compscroll_sequence[] = "b(1)s(1)e(1,0)P(1)b(80)s(2)e(80,0)P(2)"; + GenerateSequence(compscroll_sequence); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + + CreateNewTracker(FrameSequenceMetrics::ThreadType::kMain); + const char mainscroll_sequence[] = + "b(81)s(3)e(81,0)P(3)b(101)s(4)e(101,0)P(4)"; + GenerateSequence(mainscroll_sequence); + collection_.StopSequence(FrameSequenceTrackerType::kTouchScroll); + + const char comp_metric[] = + "Graphics.Smoothness.PercentDroppedFrames.CompositorThread.TouchScroll"; + const char main_metric[] = + "Graphics.Smoothness.PercentDroppedFrames.MainThread.TouchScroll"; + histogram_tester.ExpectTotalCount(comp_metric, 0u); + histogram_tester.ExpectTotalCount(main_metric, 0u); +} + } // namespace cc diff --git a/chromium/cc/metrics/latency_ukm_reporter.cc b/chromium/cc/metrics/latency_ukm_reporter.cc index 072ccb31daf..5155ee6513c 100644 --- a/chromium/cc/metrics/latency_ukm_reporter.cc +++ b/chromium/cc/metrics/latency_ukm_reporter.cc @@ -4,57 +4,108 @@ #include "cc/metrics/latency_ukm_reporter.h" +#include <climits> +#include <memory> + #include "base/rand_util.h" #include "cc/trees/ukm_manager.h" namespace cc { -void LatencyUkmReporter::ReportLatencyUkm( +// We use a Poisson process with an exponential decay multiplier. The goal is to +// get many randomly distributed samples early during page load and initial +// interaction, then samples at an exponentially decreasing rate to effectively +// cap the number of samples. The particular parameters chosen here give roughly +// 5-10 samples in the first 100 frames, decaying to several hours between +// samples by the 40th sample. The multiplier value should be tuned to achieve a +// total sample count that avoids throttling by the UKM system. +class LatencyUkmReporter::SamplingController { + public: + SamplingController() = default; + ~SamplingController() = default; + + // When a new UKM event is issued, this function should be called (once and + // only once) by the client to determine whether that event should be recorded + // or ignored, according to the sampling parameters. The sampling state will + // be updated to be ready for the next UKM event. + bool ShouldRecordNextEvent() { + bool should_record = false; + if (!frames_to_next_event_) { + should_record = true; + frames_to_next_event_ = SampleFramesToNextEvent(); + } + DCHECK_GT(frames_to_next_event_, 0); + --frames_to_next_event_; + return should_record; + } + + private: + // The |kSampleRateMultiplier| and |kSampleDecayRate| have been set to meet + // UKM goals for data volume. + const double kSampleDecayRate = 1.0; + const double kSampleRateMultiplier = 2.0; + + int SampleFramesToNextEvent() { + // Sample from an exponential distribution to give a Poisson distribution + // of samples per time unit, then weigh it with an exponential multiplier + // to give a few samples in rapid succession (for frames early in the + // page's life) then exponentially fewer as the page lives longer. + // RandDouble() returns [0,1), but we need (0,1]. If RandDouble() is + // uniformly random, so is 1-RandDouble(), so use it to adjust the range. + // When RandDouble() returns 0.0, as it could, we will get a float_sample + // of 0, causing underflow. So rejection sample until we get a positive + // count. + double float_sample = 0.0; + do { + float_sample = -(kSampleRateMultiplier * + std::exp(samples_so_far_ * kSampleDecayRate) * + std::log(1.0 - base::RandDouble())); + } while (float_sample == 0.0); + // float_sample is positive, so we don't need to worry about underflow. + // After around 30 samples we will end up with a super high sample. That's + // OK because it just means we'll stop reporting metrics for that session, + // but we do need to be careful about overflow and NaN. + samples_so_far_++; + int integer_sample = + std::isnan(float_sample) + ? INT_MAX + : base::saturated_cast<int>(std::ceil(float_sample)); + return integer_sample; + } + + int samples_so_far_ = 0; + int frames_to_next_event_ = 0; +}; + +LatencyUkmReporter::LatencyUkmReporter() + : compositor_latency_sampling_controller_( + std::make_unique<SamplingController>()), + event_latency_sampling_controller_( + std::make_unique<SamplingController>()) {} + +LatencyUkmReporter::~LatencyUkmReporter() = default; + +void LatencyUkmReporter::ReportCompositorLatencyUkm( CompositorFrameReporter::FrameReportType report_type, const std::vector<CompositorFrameReporter::StageData>& stage_history, const CompositorFrameReporter::ActiveTrackers& active_trackers, const viz::FrameTimingDetails& viz_breakdown) { - if (!ukm_manager_) - return; - if (!frames_to_next_event_) { - ukm_manager_->RecordLatencyUKM(report_type, stage_history, active_trackers, - viz_breakdown); - frames_to_next_event_ += SampleFramesToNextEvent(); + if (ukm_manager_ && + compositor_latency_sampling_controller_->ShouldRecordNextEvent()) { + ukm_manager_->RecordCompositorLatencyUKM(report_type, stage_history, + active_trackers, viz_breakdown); } - DCHECK_GT(frames_to_next_event_, 0u); - --frames_to_next_event_; } -unsigned LatencyUkmReporter::SampleFramesToNextEvent() { - // Return the test interval if set - if (frames_to_next_event_for_test_) - return frames_to_next_event_for_test_; - - // Sample from an exponential distribution to give a poisson distribution - // of samples per time unit, then weigh it with an exponential multiplier to - // give a few samples in rapid succession (for frames early in the page's - // life) then exponentially fewer as the page lives longer. - // RandDouble() returns [0,1), but we need (0,1]. If RandDouble() is - // uniformly random, so is 1-RandDouble(), so use it to adjust the range. - // When RandDouble returns 0.0, as it could, we will get a float_sample of - // 0, causing underflow in UpdateEventTimeAndRecordIfNeeded. So rejection - // sample until we get a positive count. - double float_sample = 0; - do { - float_sample = -(sample_rate_multiplier_ * - std::exp(samples_so_far_ * sample_decay_rate_) * - std::log(1.0 - base::RandDouble())); - } while (float_sample == 0); - // float_sample is positive, so we don't need to worry about underflow. - // After around 30 samples we will end up with a super high - // sample. That's OK because it just means we'll stop reporting metrics - // for that session, but we do need to be careful about overflow and NaN. - samples_so_far_++; - unsigned unsigned_sample = - std::isnan(float_sample) - ? UINT_MAX - : base::saturated_cast<unsigned>(std::ceil(float_sample)); - return unsigned_sample; +void LatencyUkmReporter::ReportEventLatencyUkm( + const std::vector<EventMetrics>& events_metrics, + const std::vector<CompositorFrameReporter::StageData>& stage_history, + const viz::FrameTimingDetails& viz_breakdown) { + if (ukm_manager_ && + event_latency_sampling_controller_->ShouldRecordNextEvent()) { + ukm_manager_->RecordEventLatencyUKM(events_metrics, stage_history, + viz_breakdown); + } } } // namespace cc diff --git a/chromium/cc/metrics/latency_ukm_reporter.h b/chromium/cc/metrics/latency_ukm_reporter.h index 3ee27823a4b..e5b0a8ac273 100644 --- a/chromium/cc/metrics/latency_ukm_reporter.h +++ b/chromium/cc/metrics/latency_ukm_reporter.h @@ -5,9 +5,12 @@ #ifndef CC_METRICS_LATENCY_UKM_REPORTER_H_ #define CC_METRICS_LATENCY_UKM_REPORTER_H_ -#include "base/optional.h" +#include <memory> +#include <vector> + #include "cc/cc_export.h" #include "cc/metrics/compositor_frame_reporter.h" +#include "cc/metrics/event_metrics.h" #include "components/viz/common/frame_timing_details.h" namespace cc { @@ -17,25 +20,27 @@ class UkmManager; // talks to UkmManager to report it. class CC_EXPORT LatencyUkmReporter { public: - LatencyUkmReporter() = default; - ~LatencyUkmReporter() = default; + LatencyUkmReporter(); + ~LatencyUkmReporter(); + + LatencyUkmReporter(const LatencyUkmReporter&) = delete; + LatencyUkmReporter& operator=(const LatencyUkmReporter&) = delete; - void ReportLatencyUkm( + void ReportCompositorLatencyUkm( CompositorFrameReporter::FrameReportType report_type, const std::vector<CompositorFrameReporter::StageData>& stage_history, const CompositorFrameReporter::ActiveTrackers& active_trackers, const viz::FrameTimingDetails& viz_breakdown); - void SetUkmManager(UkmManager* manager) { ukm_manager_ = manager; } + void ReportEventLatencyUkm( + const std::vector<EventMetrics>& events_metrics, + const std::vector<CompositorFrameReporter::StageData>& stage_history, + const viz::FrameTimingDetails& viz_breakdown); - private: - unsigned SampleFramesToNextEvent(); + void set_ukm_manager(UkmManager* manager) { ukm_manager_ = manager; } - // To test event sampling. This and all future intervals will be the given - // frame count, until this is called again. - void FramesToNextEventForTest(unsigned num_frames) { - frames_to_next_event_for_test_ = num_frames; - } + private: + class SamplingController; // This is pointing to the LayerTreeHostImpl::ukm_manager_, which is // initialized right after the LayerTreeHostImpl is created. So when this @@ -44,23 +49,8 @@ class CC_EXPORT LatencyUkmReporter { // this pointer should never be null as long as LayerTreeHostImpl is alive. UkmManager* ukm_manager_ = nullptr; - // Sampling control. We use a Poisson process with an exponential decay - // multiplier. The goal is to get many randomly distributed samples early - // during page load and initial interaction, then samples at an exponentially - // decreasing rate to effectively cap the number of samples. The particular - // parameters chosen here give roughly 5-10 samples in the first 100 frames, - // decaying to several hours between samples by the 40th sample. The - // multiplier value should be tuned to achieve a total sample count that - // avoids throttling by the UKM system. - // The sample_rate_multiplier_ and sample_decay_rate_ have been set to meet - // UKM goals for data volume. - double sample_decay_rate_ = 1; - double sample_rate_multiplier_ = 2; - unsigned samples_so_far_ = 0; - unsigned frames_to_next_event_ = 0; - - // Test data, used for SampleFramesToNextEvent if present - unsigned frames_to_next_event_for_test_ = 0; + std::unique_ptr<SamplingController> compositor_latency_sampling_controller_; + std::unique_ptr<SamplingController> event_latency_sampling_controller_; }; } // namespace cc diff --git a/chromium/cc/metrics/throughput_ukm_reporter.cc b/chromium/cc/metrics/throughput_ukm_reporter.cc index 08369a64156..39f1a33f7ce 100644 --- a/chromium/cc/metrics/throughput_ukm_reporter.cc +++ b/chromium/cc/metrics/throughput_ukm_reporter.cc @@ -30,6 +30,11 @@ void ThroughputUkmReporter::ReportThroughputUkm( const base::Optional<int>& impl_throughput_percent, const base::Optional<int>& main_throughput_percent, FrameSequenceTrackerType type) { + // It is possible that when a tab shuts down, the ukm_manager_ owned by the + // LayerTreeHostImpl is cleared, and yet we try to report to UKM here. In this + // case, the |ukm_manager_| here is null. + if (!ukm_manager_) + return; if (samples_to_next_event_[static_cast<int>(type)] == 0) { // Sample every 100 events. Using the Universal tracker as an example // which reports UMA every 5s, then the system collects UKM once per @@ -65,4 +70,42 @@ void ThroughputUkmReporter::ReportAggregateThroughput( --samples_for_aggregated_report_; } +void ThroughputUkmReporter::ComputeUniversalThroughput( + FrameSequenceMetrics* metrics) { + last_impl_percent_ = metrics->impl_throughput().DroppedFramePercent(); + last_main_percent_ = metrics->main_throughput().DroppedFramePercent(); + last_aggregated_percent_ = + metrics->aggregated_throughput().DroppedFramePercent(); +} + +bool ThroughputUkmReporter::HasThroughputData() const { + return last_aggregated_percent_.has_value(); +} + +int ThroughputUkmReporter::TakeLastAggregatedPercent() { + int ret_value = last_aggregated_percent_.value(); + DCHECK(ret_value >= 0 && ret_value <= 100); + last_aggregated_percent_ = base::nullopt; + return ret_value; +} + +int ThroughputUkmReporter::TakeLastImplPercent() { + int ret_value = last_impl_percent_.value(); + DCHECK(ret_value >= 0 && ret_value <= 100); + last_impl_percent_ = base::nullopt; + return ret_value; +} + +base::Optional<int> ThroughputUkmReporter::TakeLastMainPercent() { + base::Optional<int> ret_value = last_main_percent_; + DCHECK(!ret_value || (ret_value.value() >= 0 && ret_value.value() <= 100)); + last_main_percent_ = base::nullopt; + return ret_value; +} + +uint32_t ThroughputUkmReporter::GetSamplesToNextEventForTesting(int index) { + DCHECK_LT(index, static_cast<int>(FrameSequenceTrackerType::kMaxType)); + return samples_to_next_event_[index]; +} + } // namespace cc diff --git a/chromium/cc/metrics/throughput_ukm_reporter.h b/chromium/cc/metrics/throughput_ukm_reporter.h index 441be89f88a..c92fdfe33b4 100644 --- a/chromium/cc/metrics/throughput_ukm_reporter.h +++ b/chromium/cc/metrics/throughput_ukm_reporter.h @@ -36,6 +36,23 @@ class CC_EXPORT ThroughputUkmReporter { void ReportAggregateThroughput(AggregationType aggregation_type, int throughput); + void ComputeUniversalThroughput(FrameSequenceMetrics* metrics); + + // Once the kUniversal tracker reported its throughput to UMA, this returns + // true. In this case, the |last_aggregated_percent_| and |last_impl_percent_| + // must have value. + bool HasThroughputData() const; + // These functions are called only when HasThroughputData is true. They return + // the throughput value of the corresponding thread, and reset them to nullopt + // to indicate the value has been reported. + int TakeLastAggregatedPercent(); + int TakeLastImplPercent(); + // This could be nullopt even if the HasThroughputData() is true, because it + // could happen that all the frames are generated from the compositor thread. + base::Optional<int> TakeLastMainPercent(); + + uint32_t GetSamplesToNextEventForTesting(int index); + private: // Sampling control. We sample the event here to not throttle the UKM system. // Currently, the same sampling rate is applied to all existing trackers. We @@ -46,10 +63,20 @@ class CC_EXPORT ThroughputUkmReporter { // This is pointing to the LayerTreeHostImpl::ukm_manager_, which is // initialized right after the LayerTreeHostImpl is created. So when this - // pointer is initialized, there should be no trackers yet. Moreover, the - // LayerTreeHostImpl::ukm_manager_ lives as long as the LayerTreeHostImpl, so - // this pointer should never be null as long as LayerTreeHostImpl is alive. + // pointer is initialized, there should be no trackers yet. UkmManager* const ukm_manager_; + + // The last "PercentDroppedFrames" reported to UMA. LayerTreeHostImpl will + // read this number and send to the GPU process. When this page is done, we + // will report to UKM using these numbers. Currently only meaningful to the + // kUniversal tracker. + // Possible values: + // 1. A non-negative int value which is the percent of frames dropped. + // 2. base::nullopt: when they are fetched by LayerTreeHostImpl, so that it + // knows that the last value has been reported. + base::Optional<int> last_aggregated_percent_; + base::Optional<int> last_main_percent_; + base::Optional<int> last_impl_percent_; }; } // namespace cc diff --git a/chromium/cc/metrics/video_playback_roughness_reporter.cc b/chromium/cc/metrics/video_playback_roughness_reporter.cc index 8e76345e537..a7b77e99a65 100644 --- a/chromium/cc/metrics/video_playback_roughness_reporter.cc +++ b/chromium/cc/metrics/video_playback_roughness_reporter.cc @@ -4,6 +4,8 @@ #include "cc/metrics/video_playback_roughness_reporter.h" +#include <algorithm> + #include "base/bind_helpers.h" #include "base/metrics/histogram_macros.h" #include "components/viz/common/quads/compositor_frame_metadata.h" @@ -28,6 +30,7 @@ constexpr int VideoPlaybackRoughnessReporter::kMaxWindowSize; constexpr int VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit; constexpr int VideoPlaybackRoughnessReporter::kMinWindowsBeforeSubmit; constexpr int VideoPlaybackRoughnessReporter::kPercentileToSubmit; +constexpr double VideoPlaybackRoughnessReporter::kDesiredWindowDuration; VideoPlaybackRoughnessReporter::VideoPlaybackRoughnessReporter( PlaybackRoughnessReportingCallback reporting_cb) @@ -37,8 +40,7 @@ VideoPlaybackRoughnessReporter::~VideoPlaybackRoughnessReporter() = default; double VideoPlaybackRoughnessReporter::ConsecutiveFramesWindow::roughness() const { - return root_mean_square_error.InMicrosecondsF() / - intended_duration.InMicrosecondsF(); + return root_mean_square_error.InMillisecondsF(); } VideoPlaybackRoughnessReporter::FrameInfo::FrameInfo() = default; @@ -56,17 +58,10 @@ void VideoPlaybackRoughnessReporter::FrameSubmitted( FrameInfo info; info.token = token; - info.decode_time.emplace(); - if (!frame.metadata()->GetTimeTicks( - media::VideoFrameMetadata::DECODE_END_TIME, - &info.decode_time.value())) { - info.decode_time.reset(); - } + info.decode_time = frame.metadata()->decode_end_time; - info.intended_duration.emplace(); - if (frame.metadata()->GetTimeDelta( - media::VideoFrameMetadata::WALLCLOCK_FRAME_DURATION, - &info.intended_duration.value())) { + info.intended_duration = frame.metadata()->wallclock_frame_duration; + if (info.intended_duration) { if (render_interval > info.intended_duration.value()) { // In videos with FPS higher than display refresh rate we acknowledge // the fact that some frames will be dropped upstream and frame's intended @@ -74,27 +69,28 @@ void VideoPlaybackRoughnessReporter::FrameSubmitted( info.intended_duration = render_interval; } - // Adjust frame window size to fit about 0.5 seconds of playback - double win_size = - std::round(0.5 / info.intended_duration.value().InSecondsF()); + // Adjust frame window size to fit about 1 second of playback + double win_size = std::round(kDesiredWindowDuration / + info.intended_duration.value().InSecondsF()); frames_window_size_ = std::max(kMinWindowSize, static_cast<int>(win_size)); frames_window_size_ = std::min(frames_window_size_, kMaxWindowSize); - } else { - info.intended_duration.reset(); } + frames_.push_back(info); } void VideoPlaybackRoughnessReporter::FramePresented(TokenType token, - base::TimeTicks timestamp) { + base::TimeTicks timestamp, + bool reliable_timestamp) { for (auto it = frames_.rbegin(); it != frames_.rend(); it++) { FrameInfo& info = *it; if (token == it->token) { - info.presentation_time = timestamp; if (info.decode_time.has_value()) { auto time_since_decode = timestamp - info.decode_time.value(); UMA_HISTOGRAM_TIMES("Media.VideoFrameSubmitter", time_since_decode); } + if (reliable_timestamp) + info.presentation_time = timestamp; break; } if (viz::FrameTokenGT(token, it->token)) diff --git a/chromium/cc/metrics/video_playback_roughness_reporter.h b/chromium/cc/metrics/video_playback_roughness_reporter.h index caddf6a3922..d001df91d7c 100644 --- a/chromium/cc/metrics/video_playback_roughness_reporter.h +++ b/chromium/cc/metrics/video_playback_roughness_reporter.h @@ -25,7 +25,7 @@ using PlaybackRoughnessReportingCallback = base::RepeatingCallback< // This class tracks moments when each frame was submitted // and when it was displayed. Then series of frames split into groups -// of consecutive frames, where each group takes about 1/2 second of playback. +// of consecutive frames, where each group takes about one second of playback. // Such groups also called 'frame windows'. Each windows is assigned a roughness // score that measures how far playback smoothness was from the ideal playback. // Information about several windows and their roughness score is aggregated @@ -46,7 +46,9 @@ class CC_EXPORT VideoPlaybackRoughnessReporter { void FrameSubmitted(TokenType token, const media::VideoFrame& frame, base::TimeDelta render_interval); - void FramePresented(TokenType token, base::TimeTicks timestamp); + void FramePresented(TokenType token, + base::TimeTicks timestamp, + bool reliable_timestamp); void ProcessFrameWindow(); void Reset(); @@ -54,13 +56,13 @@ class CC_EXPORT VideoPlaybackRoughnessReporter { static constexpr int kMinWindowSize = 6; // An upper bund on how many frames can be in ConsecutiveFramesWindow - static constexpr int kMaxWindowSize = 40; + static constexpr int kMaxWindowSize = 60; // How many frame windows should be observed before reporting smoothness // due to playback time. - // 1/2 a second per window, 200 windows. It means smoothness will be reported + // 1 second per window, 100 windows. It means smoothness will be reported // for every 100 seconds of playback. - static constexpr int kMaxWindowsBeforeSubmit = 200; + static constexpr int kMaxWindowsBeforeSubmit = 100; // How many frame windows should be observed to report soothness on last // time before the destruction of the reporter. @@ -72,6 +74,13 @@ class CC_EXPORT VideoPlaybackRoughnessReporter { static_assert(kPercentileToSubmit > 0 && kPercentileToSubmit < 100, "invalid percentile value"); + // Desired duration of ConsecutiveFramesWindow in seconds. + // This value and the video FPS are being used when calculating actual + // number of frames in the ConsecutiveFramesWindow. + // kMinWindowSize and kMaxWindowSize put bounds to the window length + // and superseed this value. + static constexpr double kDesiredWindowDuration = 1.0; + private: friend class VideoPlaybackRoughnessReporterTest; struct FrameInfo { diff --git a/chromium/cc/metrics/video_playback_roughness_reporter_unittest.cc b/chromium/cc/metrics/video_playback_roughness_reporter_unittest.cc index e93cbfc3d61..053c1e77d35 100644 --- a/chromium/cc/metrics/video_playback_roughness_reporter_unittest.cc +++ b/chromium/cc/metrics/video_playback_roughness_reporter_unittest.cc @@ -5,6 +5,7 @@ #include "cc/metrics/video_playback_roughness_reporter.h" #include <algorithm> +#include <memory> #include <random> #include <vector> @@ -36,16 +37,21 @@ class VideoPlaybackRoughnessReporterTest : public ::testing::Test { scoped_refptr<VideoFrame> MakeFrame(base::TimeDelta duration) { scoped_refptr<VideoFrame> result = media::VideoFrame::CreateColorFrame( gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta()); - result->metadata()->SetTimeDelta( - VideoFrameMetadata::WALLCLOCK_FRAME_DURATION, duration); + result->metadata()->wallclock_frame_duration = duration; return result; } ::testing::AssertionResult CheckSizes() { - if (reporter()->frames_.size() > 80u) - return ::testing::AssertionFailure() - << "frames " << reporter()->frames_.size(); - if (reporter()->worst_windows_.size() > 20u) + size_t max_frames = + 2 * size_t{VideoPlaybackRoughnessReporter::kMaxWindowSize}; + if (reporter()->frames_.size() > max_frames) + return ::testing::AssertionFailure(); + + constexpr int max_worst_windows_size = + 1 + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * + (100 - VideoPlaybackRoughnessReporter::kPercentileToSubmit) / + 100; + if (reporter()->worst_windows_.size() > max_worst_windows_size) return ::testing::AssertionFailure() << "windows " << reporter()->worst_windows_.size(); return ::testing::AssertionSuccess(); @@ -60,7 +66,7 @@ class VideoPlaybackRoughnessReporterTest : public ::testing::Test { base::TimeDelta duration = vsync * frame_cadence; auto frame = MakeFrame(ideal_duration); reporter()->FrameSubmitted(idx, *frame, vsync); - reporter()->FramePresented(idx, time); + reporter()->FramePresented(idx, time, true); reporter()->ProcessFrameWindow(); time += duration; } @@ -83,7 +89,7 @@ class VideoPlaybackRoughnessReporterTest : public ::testing::Test { int presented_idx = idx - i; int frame_cadence = cadence[presented_idx % cadence.size()]; base::TimeDelta duration = vsync * frame_cadence; - reporter()->FramePresented(presented_idx, time); + reporter()->FramePresented(presented_idx, time, true); time += duration; } } @@ -98,13 +104,13 @@ TEST_F(VideoPlaybackRoughnessReporterTest, BestCase24fps) { int fps = 24; SetReportingCallabck( [&](int size, base::TimeDelta duration, double roughness) { - ASSERT_EQ(size, fps / 2); - ASSERT_NEAR(duration.InMillisecondsF(), 500.0, 1.0); - ASSERT_NEAR(roughness, 0.0118, 0.0001); + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 5.9, 0.1); call_count++; }); int frames_to_run = - VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps / 2 + 10; + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 10; NormalRun(fps, 60, {2, 3}, frames_to_run); EXPECT_EQ(call_count, 1); } @@ -114,29 +120,90 @@ TEST_F(VideoPlaybackRoughnessReporterTest, BestCase24fpsOn120Hz) { int fps = 24; SetReportingCallabck( [&](int size, base::TimeDelta duration, double roughness) { - ASSERT_EQ(size, fps / 2); - ASSERT_NEAR(duration.InMillisecondsF(), 500.0, 1.0); - ASSERT_NEAR(roughness, 0.0, 0.0001); + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 0.0, 0.1); call_count++; }); int frames_to_run = - VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps / 2 + 10; + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 10; NormalRun(fps, 120, {5}, frames_to_run); EXPECT_EQ(call_count, 1); } +TEST_F(VideoPlaybackRoughnessReporterTest, BestCase30fps) { + int call_count = 0; + int fps = 30; + SetReportingCallabck( + [&](int size, base::TimeDelta duration, double roughness) { + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 0.0, 0.1); + call_count++; + }); + int frames_to_run = + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 1; + NormalRun(fps, 60, {2}, frames_to_run); + EXPECT_EQ(call_count, 1); +} + +// This cadence pattern was used in the small user study and was found +// to be perceived by participants as not as good as ideal 30fps playback but +// better than the pattern from UserStudyBad. +// The main characteristic of this test is that cadence breaks by having a frame +// shown only once, but the very next frame is being shown 3 times thus +// fixing the synchronization. +TEST_F(VideoPlaybackRoughnessReporterTest, UserStudyOkay) { + int call_count = 0; + int fps = 30; + SetReportingCallabck( + [&](int size, base::TimeDelta duration, double roughness) { + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 4.3, 0.1); + call_count++; + }); + int frames_to_run = + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 1; + NormalRun(fps, 60, {2, 2, 2, 2, 2, 2, 1, 3, 2, 2, 2, 2, 2, 2, 2}, + frames_to_run); + EXPECT_EQ(call_count, 1); +} + +// This cadence pattern was used in the small user study and was found +// to be perceived as worst of all options in the study. +// The main characteristic of this test is that cadence breaks by having a frame +// shown only once, and it takes 2 more frames for a frame that is shown 3 times +// thus fixing the synchronization. +TEST_F(VideoPlaybackRoughnessReporterTest, UserStudyBad) { + int call_count = 0; + int fps = 30; + SetReportingCallabck( + [&](int size, base::TimeDelta duration, double roughness) { + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 7.46, 0.1); + call_count++; + }); + int frames_to_run = + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 1; + NormalRun(fps, 60, {2, 2, 2, 2, 2, 1, 2, 2, 3, 2, 2, 2, 2, 2, 2}, + frames_to_run); + EXPECT_EQ(call_count, 1); +} + TEST_F(VideoPlaybackRoughnessReporterTest, Glitchy24fps) { int call_count = 0; int fps = 24; SetReportingCallabck( [&](int size, base::TimeDelta duration, double roughness) { - ASSERT_EQ(size, fps / 2); - ASSERT_NEAR(duration.InMillisecondsF(), 500.0, 1.0); - ASSERT_NEAR(roughness, 0.0264, 0.0001); + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 14.8, 0.1); call_count++; }); int frames_to_run = - VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps / 2 + 1; + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 1; NormalRun(fps, 60, {2, 3, 1, 3, 2, 4, 2, 3, 2, 3, 3, 3}, frames_to_run); EXPECT_EQ(call_count, 1); } @@ -146,13 +213,13 @@ TEST_F(VideoPlaybackRoughnessReporterTest, BestCase60fps) { int fps = 60; SetReportingCallabck( [&](int size, base::TimeDelta duration, double roughness) { - ASSERT_EQ(size, fps / 2); - ASSERT_NEAR(duration.InMillisecondsF(), 500.0, 1.0); - ASSERT_NEAR(roughness, 0.0, 0.0001); + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 0.0, 0.1); call_count++; }); int frames_to_run = - VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps / 2 + 1; + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 1; NormalRun(fps, 60, {1}, frames_to_run); EXPECT_EQ(call_count, 1); } @@ -162,13 +229,13 @@ TEST_F(VideoPlaybackRoughnessReporterTest, BestCase50fps) { int fps = 50; SetReportingCallabck( [&](int size, base::TimeDelta duration, double roughness) { - ASSERT_EQ(size, fps / 2); - ASSERT_NEAR(duration.InMillisecondsF(), 500.0, 1.0); - ASSERT_NEAR(roughness, 0.0163, 0.0001); + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 8.1, 01); call_count++; }); int frames_to_run = - VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps / 2 + 1; + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 1; NormalRun(fps, 60, {1, 1, 1, 1, 2}, frames_to_run); EXPECT_EQ(call_count, 1); } @@ -177,19 +244,18 @@ TEST_F(VideoPlaybackRoughnessReporterTest, BestCase50fps) { // get any result we need. TEST_F(VideoPlaybackRoughnessReporterTest, PredictableRoughnessValue) { int fps = 12; - int frames_in_window = fps / 2; + int frames_in_window = fps; int call_count = 0; - double intended_roughness = 0.042; + double intended_roughness = 4.2; base::TimeDelta vsync = base::TimeDelta::FromSecondsD(1.0 / fps); // Calculating the error value that needs to be injected into one frame // in order to get desired roughness. - base::TimeDelta error = - std::sqrt(intended_roughness * intended_roughness * frames_in_window) * - frames_in_window * vsync; + base::TimeDelta error = base::TimeDelta::FromMillisecondsD( + std::sqrt(intended_roughness * intended_roughness * frames_in_window)); auto callback = [&](int size, base::TimeDelta duration, double roughness) { ASSERT_EQ(frames_in_window, size); - ASSERT_NEAR(roughness, intended_roughness, 0.0001); + ASSERT_NEAR(roughness, intended_roughness, 0.1); call_count++; }; SetReportingCallabck(callback); @@ -204,7 +270,7 @@ TEST_F(VideoPlaybackRoughnessReporterTest, PredictableRoughnessValue) { auto frame = MakeFrame(vsync); reporter()->FrameSubmitted(token, *frame, vsync); - reporter()->FramePresented(token++, time); + reporter()->FramePresented(token++, time, true); reporter()->ProcessFrameWindow(); } } @@ -216,22 +282,22 @@ TEST_F(VideoPlaybackRoughnessReporterTest, PredictableRoughnessValue) { TEST_F(VideoPlaybackRoughnessReporterTest, TakingPercentile) { int token = 0; int fps = 12; - int frames_in_window = fps / 2; + int frames_in_window = fps; int call_count = 0; int win_count = 100; base::TimeDelta vsync = base::TimeDelta::FromSecondsD(1.0 / fps); std::vector<double> targets; targets.reserve(win_count); for (int i = 0; i < win_count; i++) - targets.push_back(i * 0.0001); + targets.push_back(i * 0.1); double expected_roughness = - VideoPlaybackRoughnessReporter::kPercentileToSubmit * 0.0001; + VideoPlaybackRoughnessReporter::kPercentileToSubmit * 0.1; std::mt19937 rnd(1); std::shuffle(targets.begin(), targets.end(), rnd); auto callback = [&](int size, base::TimeDelta duration, double roughness) { ASSERT_EQ(frames_in_window, size); - ASSERT_NEAR(roughness, expected_roughness, 0.00001); + ASSERT_NEAR(roughness, expected_roughness, 0.05); call_count++; }; SetReportingCallabck(callback); @@ -240,9 +306,8 @@ TEST_F(VideoPlaybackRoughnessReporterTest, TakingPercentile) { double roughness = targets[win_idx]; // Calculating the error value that needs to be injected into one frame // in order to get desired roughness. - base::TimeDelta error = - std::sqrt(roughness * roughness * frames_in_window) * frames_in_window * - vsync; + base::TimeDelta error = base::TimeDelta::FromMillisecondsD( + std::sqrt(roughness * roughness * frames_in_window)); for (int frame_idx = 0; frame_idx < frames_in_window; frame_idx++) { base::TimeTicks time; @@ -252,7 +317,7 @@ TEST_F(VideoPlaybackRoughnessReporterTest, TakingPercentile) { auto frame = MakeFrame(vsync); reporter()->FrameSubmitted(token, *frame, vsync); - reporter()->FramePresented(token++, time); + reporter()->FramePresented(token++, time, true); reporter()->ProcessFrameWindow(); } } @@ -271,7 +336,7 @@ TEST_F(VideoPlaybackRoughnessReporterTest, LongRunWithoutWindows) { auto frame = MakeFrame(vsync); reporter()->FrameSubmitted(i, *frame, vsync); if (i % 2 == 0) - reporter()->FramePresented(i, base::TimeTicks() + i * vsync); + reporter()->FramePresented(i, base::TimeTicks() + i * vsync, true); reporter()->ProcessFrameWindow(); ASSERT_TRUE(CheckSizes()); } @@ -288,7 +353,24 @@ TEST_F(VideoPlaybackRoughnessReporterTest, PresentingUnknownFrames) { for (int i = 0; i < 10000; i++) { auto frame = MakeFrame(vsync); reporter()->FrameSubmitted(i, *frame, vsync); - reporter()->FramePresented(i + 100000, base::TimeTicks() + i * vsync); + reporter()->FramePresented(i + 100000, base::TimeTicks() + i * vsync, true); + reporter()->ProcessFrameWindow(); + ASSERT_TRUE(CheckSizes()); + } + EXPECT_EQ(call_count, 0); +} + +// Test that the reporter is ignoring frames with unreliable +// presentation timestamp. +TEST_F(VideoPlaybackRoughnessReporterTest, IgnoringUnreliableTimings) { + int call_count = 0; + base::TimeDelta vsync = base::TimeDelta::FromMilliseconds(1); + SetReportingCallabck([&](int size, base::TimeDelta duration, + double roughness) { call_count++; }); + for (int i = 0; i < 10000; i++) { + auto frame = MakeFrame(vsync); + reporter()->FrameSubmitted(i, *frame, vsync); + reporter()->FramePresented(i, base::TimeTicks() + i * vsync, false); reporter()->ProcessFrameWindow(); ASSERT_TRUE(CheckSizes()); } @@ -307,7 +389,7 @@ TEST_F(VideoPlaybackRoughnessReporterTest, ReportingInReset) { // Set number of frames insufficient for reporting in Reset() int frames_to_run = - VideoPlaybackRoughnessReporter::kMinWindowsBeforeSubmit * fps / 2 - 1; + VideoPlaybackRoughnessReporter::kMinWindowsBeforeSubmit * fps - 1; NormalRun(fps, 60, {1}, frames_to_run); // No calls since, not enough windows were reported EXPECT_EQ(call_count, 0); @@ -318,7 +400,7 @@ TEST_F(VideoPlaybackRoughnessReporterTest, ReportingInReset) { // Set number of frames sufficient for reporting in Reset() frames_to_run = - VideoPlaybackRoughnessReporter::kMinWindowsBeforeSubmit * fps / 2 + 1; + VideoPlaybackRoughnessReporter::kMinWindowsBeforeSubmit * fps + 1; NormalRun(fps, 60, {1}, frames_to_run); // No calls since, not enough windows were reported @@ -338,27 +420,27 @@ TEST_F(VideoPlaybackRoughnessReporterTest, BatchPresentation) { // Try 60 fps SetReportingCallabck( [&](int size, base::TimeDelta duration, double roughness) { - ASSERT_EQ(size, fps / 2); - ASSERT_NEAR(duration.InMillisecondsF(), 500.0, 1.0); - ASSERT_NEAR(roughness, 0.0, 0.0001); + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 0.0, 0.1); call_count++; }); int frames_to_run = - VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps / 2 + 10; + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 10; BatchPresentationRun(fps, 60, {1}, frames_to_run); EXPECT_EQ(call_count, 1); // Try 24fps SetReportingCallabck( [&](int size, base::TimeDelta duration, double roughness) { - ASSERT_EQ(size, fps / 2); - ASSERT_NEAR(duration.InMillisecondsF(), 500.0, 1.0); - ASSERT_NEAR(roughness, 0.0118, 0.0001); + ASSERT_EQ(size, fps); + ASSERT_NEAR(duration.InMillisecondsF(), 1000.0, 1.0); + ASSERT_NEAR(roughness, 5.9, 0.1); call_count++; }); fps = 24; frames_to_run = - VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps / 2 + 10; + VideoPlaybackRoughnessReporter::kMaxWindowsBeforeSubmit * fps + 10; BatchPresentationRun(fps, 60, {2, 3}, frames_to_run); EXPECT_EQ(call_count, 2); } diff --git a/chromium/cc/paint/BUILD.gn b/chromium/cc/paint/BUILD.gn index 4c3776c0411..0a9161d4e66 100644 --- a/chromium/cc/paint/BUILD.gn +++ b/chromium/cc/paint/BUILD.gn @@ -107,6 +107,7 @@ cc_component("paint") { deps = [ "//base", + "//gpu/command_buffer/common:mailbox", "//ui/gfx/animation", "//ui/gfx/ipc/color", ] diff --git a/chromium/cc/paint/decoded_draw_image.cc b/chromium/cc/paint/decoded_draw_image.cc index 2c66554d449..69f195f2bb4 100644 --- a/chromium/cc/paint/decoded_draw_image.cc +++ b/chromium/cc/paint/decoded_draw_image.cc @@ -17,6 +17,14 @@ DecodedDrawImage::DecodedDrawImage(sk_sp<const SkImage> image, filter_quality_(filter_quality), is_budgeted_(is_budgeted) {} +DecodedDrawImage::DecodedDrawImage(const gpu::Mailbox& mailbox, + SkFilterQuality filter_quality) + : mailbox_(mailbox), + src_rect_offset_(SkSize::MakeEmpty()), + scale_adjustment_(SkSize::Make(1.f, 1.f)), + filter_quality_(filter_quality), + is_budgeted_(true) {} + DecodedDrawImage::DecodedDrawImage( base::Optional<uint32_t> transfer_cache_entry_id, const SkSize& src_rect_offset, diff --git a/chromium/cc/paint/decoded_draw_image.h b/chromium/cc/paint/decoded_draw_image.h index 02b3ad1092c..a3e47d30fc0 100644 --- a/chromium/cc/paint/decoded_draw_image.h +++ b/chromium/cc/paint/decoded_draw_image.h @@ -10,6 +10,7 @@ #include "base/optional.h" #include "cc/paint/paint_export.h" +#include "gpu/command_buffer/common/mailbox.h" #include "third_party/skia/include/core/SkFilterQuality.h" #include "third_party/skia/include/core/SkImage.h" #include "third_party/skia/include/core/SkRefCnt.h" @@ -29,6 +30,7 @@ class CC_PAINT_EXPORT DecodedDrawImage { const SkSize& scale_adjustment, SkFilterQuality filter_quality, bool is_budgeted); + DecodedDrawImage(const gpu::Mailbox& mailbox, SkFilterQuality filter_quality); DecodedDrawImage(base::Optional<uint32_t> transfer_cache_entry_id, const SkSize& src_rect_offset, const SkSize& scale_adjustment, @@ -62,6 +64,7 @@ class CC_PAINT_EXPORT DecodedDrawImage { private: sk_sp<const SkImage> image_; + gpu::Mailbox mailbox_; base::Optional<uint32_t> transfer_cache_entry_id_; SkSize src_rect_offset_; SkSize scale_adjustment_; diff --git a/chromium/cc/paint/discardable_image_map_unittest.cc b/chromium/cc/paint/discardable_image_map_unittest.cc index fd52a353fcc..380ee6d6ae2 100644 --- a/chromium/cc/paint/discardable_image_map_unittest.cc +++ b/chromium/cc/paint/discardable_image_map_unittest.cc @@ -626,8 +626,8 @@ TEST_F(DiscardableImageMapTest, GetDiscardableImagesInShader) { .set_paint_image_generator( CreatePaintImageGenerator(gfx::Size(500, 500))) .TakePaintImage(); - SkMatrix scale = SkMatrix::MakeScale(std::max(x * 0.5f, kMinScale), - std::max(y * 0.5f, kMinScale)); + SkMatrix scale = SkMatrix::Scale(std::max(x * 0.5f, kMinScale), + std::max(y * 0.5f, kMinScale)); PaintFlags flags; flags.setShader(PaintShader::MakeImage(discardable_image[y][x], SkTileMode::kClamp, diff --git a/chromium/cc/paint/display_item_list.cc b/chromium/cc/paint/display_item_list.cc index 52a3aac9f07..071f57b646f 100644 --- a/chromium/cc/paint/display_item_list.cc +++ b/chromium/cc/paint/display_item_list.cc @@ -296,7 +296,6 @@ void DisplayItemList::Reset() { offsets_.shrink_to_fit(); paired_begin_stack_.clear(); paired_begin_stack_.shrink_to_fit(); - has_draw_ops_ = false; } sk_sp<PaintRecord> DisplayItemList::ReleaseAsRecord() { diff --git a/chromium/cc/paint/display_item_list.h b/chromium/cc/paint/display_item_list.h index b518d67715a..c065c33e60a 100644 --- a/chromium/cc/paint/display_item_list.h +++ b/chromium/cc/paint/display_item_list.h @@ -91,8 +91,6 @@ class CC_PAINT_EXPORT DisplayItemList if (usage_hint_ == kTopLevelDisplayItemList) offsets_.push_back(offset); const T* op = paint_op_buffer_.push<T>(std::forward<Args>(args)...); - if (op->IsDrawOp()) - has_draw_ops_ = true; DCHECK(op->IsValid()); return offset; } @@ -181,11 +179,17 @@ class CC_PAINT_EXPORT DisplayItemList int max_ops_to_analyze = 1); std::string ToString() const; - bool has_draw_ops() const { return has_draw_ops_; } + bool has_draw_ops() const { return paint_op_buffer_.has_draw_ops(); } // Ops with nested paint ops are considered as a single op. size_t num_paint_ops() const { return paint_op_buffer_.size(); } + bool NeedsAdditionalInvalidationForLCDText( + const DisplayItemList& old_list) const { + return paint_op_buffer_.NeedsAdditionalInvalidationForLCDText( + old_list.paint_op_buffer_); + } + private: friend class DisplayItemListTest; friend gpu::raster::RasterImplementation; @@ -238,7 +242,6 @@ class CC_PAINT_EXPORT DisplayItemList #endif UsageHint usage_hint_; - bool has_draw_ops_ = false; friend class base::RefCountedThreadSafe<DisplayItemList>; FRIEND_TEST_ALL_PREFIXES(DisplayItemListTest, BytesUsed); diff --git a/chromium/cc/paint/display_item_list_unittest.cc b/chromium/cc/paint/display_item_list_unittest.cc index a4dea57bbfb..a8230788bbb 100644 --- a/chromium/cc/paint/display_item_list_unittest.cc +++ b/chromium/cc/paint/display_item_list_unittest.cc @@ -8,6 +8,7 @@ #include <vector> +#include "base/logging.h" #include "base/trace_event/traced_value.h" #include "base/values.h" #include "cc/paint/filter_operation.h" diff --git a/chromium/cc/paint/element_id.cc b/chromium/cc/paint/element_id.cc index 3465eb1117a..a5b11cb2da2 100644 --- a/chromium/cc/paint/element_id.cc +++ b/chromium/cc/paint/element_id.cc @@ -15,6 +15,11 @@ namespace cc { const ElementIdType ElementId::kInvalidElementId = 0; +// static +bool ElementId::IsValid(ElementIdType id) { + return id != kInvalidElementId; +} + ElementId LayerIdToElementIdForTesting(int layer_id) { return ElementId(std::numeric_limits<int>::max() - layer_id); } diff --git a/chromium/cc/paint/element_id.h b/chromium/cc/paint/element_id.h index a4108a13b37..fcdebf565b7 100644 --- a/chromium/cc/paint/element_id.h +++ b/chromium/cc/paint/element_id.h @@ -63,6 +63,8 @@ struct CC_PAINT_EXPORT ElementId { std::string ToString() const; + static bool IsValid(ElementIdType id); + private: friend struct ElementIdHash; static const ElementIdType kInvalidElementId; diff --git a/chromium/cc/paint/filter_operation.h b/chromium/cc/paint/filter_operation.h index e1c018b9be3..8971192195f 100644 --- a/chromium/cc/paint/filter_operation.h +++ b/chromium/cc/paint/filter_operation.h @@ -8,7 +8,7 @@ #include <memory> #include <vector> -#include "base/logging.h" +#include "base/check_op.h" #include "cc/paint/paint_export.h" #include "cc/paint/paint_filter.h" #include "third_party/skia/include/core/SkColor.h" diff --git a/chromium/cc/paint/filter_operations.h b/chromium/cc/paint/filter_operations.h index 5bc51ad8ec8..1186796cd1a 100644 --- a/chromium/cc/paint/filter_operations.h +++ b/chromium/cc/paint/filter_operations.h @@ -10,7 +10,7 @@ #include <string> #include <vector> -#include "base/logging.h" +#include "base/check_op.h" #include "cc/paint/filter_operation.h" namespace base { diff --git a/chromium/cc/paint/filter_operations_unittest.cc b/chromium/cc/paint/filter_operations_unittest.cc index 93b3dbb0eed..7e4fdc4834d 100644 --- a/chromium/cc/paint/filter_operations_unittest.cc +++ b/chromium/cc/paint/filter_operations_unittest.cc @@ -23,9 +23,9 @@ TEST(FilterOperationsTest, MapRectBlur) { EXPECT_EQ(gfx::Rect(-60, -60, 130, 130), ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); EXPECT_EQ(gfx::Rect(-120, -120, 260, 260), - ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); + ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ(gfx::Rect(-60, -70, 130, 130), - ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::MakeScale(1, -1))); + ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectBlurOverflow) { @@ -43,10 +43,10 @@ TEST(FilterOperationsTest, MapRectReverseBlur) { ops.MapRectReverse(gfx::Rect(0, 0, 150, 150), SkMatrix::I())); EXPECT_EQ( gfx::Rect(120, 120, 60, 60), - ops.MapRectReverse(gfx::Rect(0, 0, 300, 300), SkMatrix::MakeScale(2, 2))); - EXPECT_EQ(gfx::Rect(60, 50, 30, 30), - ops.MapRectReverse(gfx::Rect(0, -10, 150, 150), - SkMatrix::MakeScale(1, -1))); + ops.MapRectReverse(gfx::Rect(0, 0, 300, 300), SkMatrix::Scale(2, 2))); + EXPECT_EQ( + gfx::Rect(60, 50, 30, 30), + ops.MapRectReverse(gfx::Rect(0, -10, 150, 150), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectDropShadowReferenceFilter) { @@ -60,9 +60,9 @@ TEST(FilterOperationsTest, MapRectDropShadowReferenceFilter) { EXPECT_EQ(gfx::Rect(-9, -19, 34, 64), ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); EXPECT_EQ(gfx::Rect(-18, -38, 68, 128), - ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); + ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ(gfx::Rect(-9, -45, 34, 64), - ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::MakeScale(1, -1))); + ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectReverseDropShadowReferenceFilter) { @@ -75,12 +75,11 @@ TEST(FilterOperationsTest, MapRectReverseDropShadowReferenceFilter) { nullptr))); EXPECT_EQ(gfx::Rect(-15, -35, 34, 64), ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); + EXPECT_EQ(gfx::Rect(-30, -70, 68, 128), + ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ( - gfx::Rect(-30, -70, 68, 128), - ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); - EXPECT_EQ(gfx::Rect(-15, -29, 34, 64), - ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), - SkMatrix::MakeScale(1, -1))); + gfx::Rect(-15, -29, 34, 64), + ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectOffsetReferenceFilter) { @@ -90,9 +89,9 @@ TEST(FilterOperationsTest, MapRectOffsetReferenceFilter) { EXPECT_EQ(gfx::Rect(30, 40, 10, 10), ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); EXPECT_EQ(gfx::Rect(60, 80, 20, 20), - ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); + ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ(gfx::Rect(30, -50, 10, 10), - ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::MakeScale(1, -1))); + ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectReverseOffsetReferenceFilter) { @@ -101,12 +100,11 @@ TEST(FilterOperationsTest, MapRectReverseOffsetReferenceFilter) { ops.Append(FilterOperation::CreateReferenceFilter(std::move(filter))); EXPECT_EQ(gfx::Rect(-30, -40, 10, 10), ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); + EXPECT_EQ(gfx::Rect(-60, -80, 20, 20), + ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ( - gfx::Rect(-60, -80, 20, 20), - ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); - EXPECT_EQ(gfx::Rect(-30, 30, 10, 10), - ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), - SkMatrix::MakeScale(1, -1))); + gfx::Rect(-30, 30, 10, 10), + ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectCombineNonCommutative) { @@ -123,9 +121,9 @@ TEST(FilterOperationsTest, MapRectCombineNonCommutative) { EXPECT_EQ(gfx::Rect(200, 200, 20, 20), ops.MapRect(gfx::Rect(10, 10), SkMatrix::I())); EXPECT_EQ(gfx::Rect(400, 400, 40, 40), - ops.MapRect(gfx::Rect(20, 20), SkMatrix::MakeScale(2, 2))); + ops.MapRect(gfx::Rect(20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ(gfx::Rect(200, -220, 20, 20), - ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::MakeScale(1, -1))); + ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectReverseCombineNonCommutative) { @@ -142,10 +140,10 @@ TEST(FilterOperationsTest, MapRectReverseCombineNonCommutative) { EXPECT_EQ(gfx::Rect(10, 10), ops.MapRectReverse(gfx::Rect(200, 200, 20, 20), SkMatrix::I())); EXPECT_EQ(gfx::Rect(20, 20), ops.MapRectReverse(gfx::Rect(400, 400, 40, 40), - SkMatrix::MakeScale(2, 2))); - EXPECT_EQ(gfx::Rect(0, -10, 10, 10), - ops.MapRectReverse(gfx::Rect(200, -220, 20, 20), - SkMatrix::MakeScale(1, -1))); + SkMatrix::Scale(2, 2))); + EXPECT_EQ( + gfx::Rect(0, -10, 10, 10), + ops.MapRectReverse(gfx::Rect(200, -220, 20, 20), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectNullReferenceFilter) { @@ -154,9 +152,9 @@ TEST(FilterOperationsTest, MapRectNullReferenceFilter) { EXPECT_EQ(gfx::Rect(0, 0, 10, 10), ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); EXPECT_EQ(gfx::Rect(0, 0, 20, 20), - ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); + ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ(gfx::Rect(0, -10, 10, 10), - ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::MakeScale(1, -1))); + ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectReverseNullReferenceFilter) { @@ -164,12 +162,11 @@ TEST(FilterOperationsTest, MapRectReverseNullReferenceFilter) { ops.Append(FilterOperation::CreateReferenceFilter(nullptr)); EXPECT_EQ(gfx::Rect(0, 0, 10, 10), ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); + EXPECT_EQ(gfx::Rect(0, 0, 20, 20), + ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ( - gfx::Rect(0, 0, 20, 20), - ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); - EXPECT_EQ(gfx::Rect(0, -10, 10, 10), - ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), - SkMatrix::MakeScale(1, -1))); + gfx::Rect(0, -10, 10, 10), + ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectDropShadow) { @@ -178,9 +175,9 @@ TEST(FilterOperationsTest, MapRectDropShadow) { EXPECT_EQ(gfx::Rect(-57, -52, 130, 130), ops.MapRect(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); EXPECT_EQ(gfx::Rect(-114, -104, 260, 260), - ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); + ops.MapRect(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ(gfx::Rect(-57, -78, 130, 130), - ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::MakeScale(1, -1))); + ops.MapRect(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectReverseDropShadow) { @@ -188,12 +185,11 @@ TEST(FilterOperationsTest, MapRectReverseDropShadow) { ops.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(3, 8), 20, 0)); EXPECT_EQ(gfx::Rect(-63, -68, 130, 130), ops.MapRectReverse(gfx::Rect(0, 0, 10, 10), SkMatrix::I())); + EXPECT_EQ(gfx::Rect(-126, -136, 260, 260), + ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::Scale(2, 2))); EXPECT_EQ( - gfx::Rect(-126, -136, 260, 260), - ops.MapRectReverse(gfx::Rect(0, 0, 20, 20), SkMatrix::MakeScale(2, 2))); - EXPECT_EQ(gfx::Rect(-63, -62, 130, 130), - ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), - SkMatrix::MakeScale(1, -1))); + gfx::Rect(-63, -62, 130, 130), + ops.MapRectReverse(gfx::Rect(0, -10, 10, 10), SkMatrix::Scale(1, -1))); } TEST(FilterOperationsTest, MapRectDropShadowDoesNotContract) { diff --git a/chromium/cc/paint/image_transfer_cache_entry.cc b/chromium/cc/paint/image_transfer_cache_entry.cc index 155d95f1e3b..1f669ebefb4 100644 --- a/chromium/cc/paint/image_transfer_cache_entry.cc +++ b/chromium/cc/paint/image_transfer_cache_entry.cc @@ -24,6 +24,14 @@ namespace cc { namespace { +struct Context { + const std::vector<sk_sp<SkImage>> sk_planes_; +}; + +void ReleaseContext(SkImage::ReleaseContext context) { + auto* texture_context = static_cast<Context*>(context); + delete texture_context; +} // Creates a SkImage backed by the YUV textures corresponding to |plane_images|. // The layout is specified by |plane_images_format|). The backend textures are @@ -81,10 +89,11 @@ sk_sp<SkImage> MakeYUVImageFromUploadedPlanes( return nullptr; } plane_indices[SkYUVAIndex::kA_Index] = {-1, SkColorChannel::kR}; + Context* ctx = new Context{plane_images}; sk_sp<SkImage> image = SkImage::MakeFromYUVATextures( context, yuv_color_space, plane_backend_textures.data(), plane_indices, plane_images[0]->dimensions(), kTopLeft_GrSurfaceOrigin, - std::move(image_color_space)); + std::move(image_color_space), ReleaseContext, ctx); if (!image) { DLOG(ERROR) << "Could not create YUV image"; return nullptr; diff --git a/chromium/cc/paint/image_transfer_cache_entry_unittest.cc b/chromium/cc/paint/image_transfer_cache_entry_unittest.cc index 24a334eedbb..0da5db2f946 100644 --- a/chromium/cc/paint/image_transfer_cache_entry_unittest.cc +++ b/chromium/cc/paint/image_transfer_cache_entry_unittest.cc @@ -144,7 +144,7 @@ class ImageTransferCacheEntryTest if (texture.isValid()) gr_context_->deleteBackendTexture(texture); } - gr_context_->flush(); + gr_context_->flushAndSubmit(); textures_to_free_.clear(); } diff --git a/chromium/cc/paint/oop_pixeltest.cc b/chromium/cc/paint/oop_pixeltest.cc index 6c9f1c1e192..ffc090ebee1 100644 --- a/chromium/cc/paint/oop_pixeltest.cc +++ b/chromium/cc/paint/oop_pixeltest.cc @@ -332,7 +332,7 @@ class OopPixelTest : public testing::Test, raster_source->PlaybackToCanvas( canvas, options.content_size, options.full_raster_rect, options.playback_rect, raster_transform, settings); - surface->flush(); + surface->flushAndSubmit(); EXPECT_EQ(gles2_context_provider_->ContextGL()->GetError(), static_cast<unsigned>(GL_NO_ERROR)); @@ -852,7 +852,7 @@ TEST_P(OopImagePixelTest, DrawImageWithSetMatrix) { display_item_list->StartPaint(); PaintFlags flags; flags.setFilterQuality(FilterQuality()); - display_item_list->push<SetMatrixOp>(SkMatrix::MakeScale(0.5f, 0.5f)); + display_item_list->push<SetMatrixOp>(SkMatrix::Scale(0.5f, 0.5f)); display_item_list->push<DrawImageOp>(paint_image, 0.f, 0.f, &flags); display_item_list->EndPaintOfUnpaired(rect); display_item_list->Finalize(); @@ -1358,6 +1358,39 @@ TEST_F(OopPixelTest, DrawRectScaleTransformOptions) { ExpectEquals(actual, expected); } +TEST_F(OopPixelTest, DrawRectTransformOptionsFullRaster) { + PaintFlags flags; + // Use powers of two here to make floating point blending consistent. + flags.setColor(SkColorSetRGB(64, 128, 32)); + flags.setAntiAlias(true); + gfx::Rect draw_rect(0, 0, 19, 19); + + auto display_item_list = base::MakeRefCounted<DisplayItemList>(); + display_item_list->StartPaint(); + display_item_list->push<DrawRectOp>(gfx::RectToSkRect(draw_rect), flags); + display_item_list->EndPaintOfUnpaired(draw_rect); + display_item_list->Finalize(); + + // The opaque rect above is 1px smaller than the canvas. With the subpixel + // translation, the rect fills the whole canvas, but the pixels at the edges + // are translucent. We should clear the canvas before drawing the rect, so + // the translucent pixels at the edges should not expose the preclear color, + // even if requires_clear is not true. + RasterOptions options; + options.resource_size = {20, 20}; + options.content_size = {25, 25}; + options.full_raster_rect = {5, 5, 20, 20}; + options.playback_rect = {5, 5, 20, 20}; + options.preclear = true; + options.preclear_color = SK_ColorRED; + options.post_translate = {0.5f, 0.25f}; + options.post_scale = 2.f; + + auto actual = Raster(display_item_list, options); + auto expected = RasterExpectedBitmap(display_item_list, options); + ExpectEquals(actual, expected); +} + TEST_F(OopPixelTest, DrawRectQueryMiddleOfDisplayList) { auto display_item_list = base::MakeRefCounted<DisplayItemList>(); std::vector<SkColor> colors = { @@ -1546,12 +1579,12 @@ class OopRecordFilterPixelTest : public OopPixelTest, }; TEST_P(OopRecordFilterPixelTest, FilterWithTextScaled) { - SkMatrix mat = SkMatrix::MakeScale(2.f, 2.f); + SkMatrix mat = SkMatrix::Scale(2.f, 2.f); RunTest(mat); } TEST_P(OopRecordFilterPixelTest, FilterWithTextAndComplexCTM) { - SkMatrix mat = SkMatrix::MakeScale(2.f, 2.f); + SkMatrix mat = SkMatrix::Scale(2.f, 2.f); mat.preSkew(2.f, 2.f); RunTest(mat); } diff --git a/chromium/cc/paint/paint_canvas.h b/chromium/cc/paint/paint_canvas.h index 8a0883b7fc8..2b9c34a2336 100644 --- a/chromium/cc/paint/paint_canvas.h +++ b/chromium/cc/paint/paint_canvas.h @@ -146,16 +146,11 @@ class CC_PAINT_EXPORT PaintCanvas { drawImage(image, left, top, nullptr); } - enum SrcRectConstraint { - kStrict_SrcRectConstraint = SkCanvas::kStrict_SrcRectConstraint, - kFast_SrcRectConstraint = SkCanvas::kFast_SrcRectConstraint, - }; - virtual void drawImageRect(const PaintImage& image, const SkRect& src, const SkRect& dst, const PaintFlags* flags, - SrcRectConstraint constraint) = 0; + SkCanvas::SrcRectConstraint constraint) = 0; // Draws the frame of the |skottie| animation specified by the normalized time // t [0->first frame..1->last frame] at the destination bounds given by |dst| diff --git a/chromium/cc/paint/paint_filter.cc b/chromium/cc/paint/paint_filter.cc index 279258b26b7..cf868e21167 100644 --- a/chromium/cc/paint/paint_filter.cc +++ b/chromium/cc/paint/paint_filter.cc @@ -701,7 +701,7 @@ sk_sp<PaintFilter> ImagePaintFilter::SnapshotWithImagesInternal( PaintImage decoded_paint_image = PaintImageBuilder::WithDefault() .set_id(image_.stable_id()) - .set_image(decoded_sk_image, PaintImage::GetNextContentId()) + .set_texture_image(decoded_sk_image, PaintImage::GetNextContentId()) .TakePaintImage(); return sk_make_sp<ImagePaintFilter>(std::move(decoded_paint_image), src_rect_, diff --git a/chromium/cc/paint/paint_filter.h b/chromium/cc/paint/paint_filter.h index cec36ef7c6a..556ab9a91e8 100644 --- a/chromium/cc/paint/paint_filter.h +++ b/chromium/cc/paint/paint_filter.h @@ -5,8 +5,8 @@ #ifndef CC_PAINT_PAINT_FILTER_H_ #define CC_PAINT_PAINT_FILTER_H_ +#include "base/check_op.h" #include "base/containers/stack_container.h" -#include "base/logging.h" #include "base/optional.h" #include "base/stl_util.h" #include "cc/paint/paint_export.h" diff --git a/chromium/cc/paint/paint_flags.h b/chromium/cc/paint/paint_flags.h index c1f1cb5ce2f..e28e68929c9 100644 --- a/chromium/cc/paint/paint_flags.h +++ b/chromium/cc/paint/paint_flags.h @@ -33,7 +33,6 @@ class CC_PAINT_EXPORT PaintFlags { enum Style { kFill_Style = SkPaint::kFill_Style, kStroke_Style = SkPaint::kStroke_Style, - kStrokeAndFill_Style = SkPaint::kStrokeAndFill_Style, }; bool nothingToDraw() const; ALWAYS_INLINE Style getStyle() const { @@ -141,9 +140,13 @@ class CC_PAINT_EXPORT PaintFlags { draw_looper_ = std::move(looper); } - // Returns true if this just represents an opacity blend when - // used as saveLayer flags. + // Returns true if this just represents an opacity blend when used as + // saveLayer flags, thus the saveLayer can be converted to a saveLayerAlpha. bool IsSimpleOpacity() const; + + // Returns true if this (of a drawOp) allows the sequence + // saveLayerAlpha/drawOp/restore to be folded into a single drawOp by baking + // the alpha in the saveLayerAlpha into the flags of the drawOp. bool SupportsFoldingAlpha() const; // SkPaint does not support loopers, so callers of SkToPaint need diff --git a/chromium/cc/paint/paint_image.cc b/chromium/cc/paint/paint_image.cc index 86deeddd70f..529718556d9 100644 --- a/chromium/cc/paint/paint_image.cc +++ b/chromium/cc/paint/paint_image.cc @@ -5,6 +5,7 @@ #include "cc/paint/paint_image.h" #include <memory> +#include <sstream> #include "base/atomic_sequence_num.h" #include "base/hash/hash.h" @@ -113,6 +114,15 @@ const sk_sp<SkImage>& PaintImage::GetSkImage() const { return cached_sk_image_; } +const sk_sp<SkImage>& PaintImage::GetRasterSkImage() const { + return cached_sk_image_; +} + +gpu::Mailbox PaintImage::GetMailbox() const { + DCHECK(texture_backing_); + return texture_backing_->GetMailbox(); +} + PaintImage PaintImage::MakeSubset(const gfx::Rect& subset) const { DCHECK(!subset.IsEmpty()); @@ -133,7 +143,7 @@ PaintImage PaintImage::MakeSubset(const gfx::Rect& subset) const { // PaintImage is an optimization to allow re-use of the original decode for // image subsets in skia, for cases that rely on skia's image decode cache. result.cached_sk_image_ = - GetSkImage()->makeSubset(gfx::RectToSkIRect(subset)); + GetRasterSkImage()->makeSubset(gfx::RectToSkIRect(subset)); return result; } @@ -288,6 +298,14 @@ SkAlphaType PaintImage::GetAlphaType() const { return kUnknown_SkAlphaType; } +bool PaintImage::IsTextureBacked() const { + if (texture_backing_) + return true; + if (cached_sk_image_) + return cached_sk_image_->isTextureBacked(); + return false; +} + int PaintImage::width() const { return paint_worklet_input_ ? static_cast<int>(paint_worklet_input_->GetSize().width()) @@ -361,18 +379,19 @@ sk_sp<SkImage> PaintImage::GetSkImageForFrame( size_t index, GeneratorClientId client_id) const { DCHECK_LT(index, FrameCount()); + DCHECK(!IsTextureBacked()); // |client_id| and |index| are only relevant for generator backed images which // perform lazy decoding and can be multi-frame. if (!paint_image_generator_) { DCHECK_EQ(index, kDefaultFrameIndex); - return GetSkImage(); + return GetRasterSkImage(); } // The internally cached SkImage is constructed using the default frame index // and GeneratorClientId. Avoid creating a new SkImage. if (index == kDefaultFrameIndex && client_id == kDefaultGeneratorClientId) - return GetSkImage(); + return GetRasterSkImage(); sk_sp<SkImage> image = SkImage::MakeFromGenerator(std::make_unique<SkiaPaintImageGenerator>( diff --git a/chromium/cc/paint/paint_image.h b/chromium/cc/paint/paint_image.h index 95881204e0a..1d7503a2d04 100644 --- a/chromium/cc/paint/paint_image.h +++ b/chromium/cc/paint/paint_image.h @@ -8,12 +8,12 @@ #include <vector> #include "base/gtest_prod_util.h" -#include "base/logging.h" #include "base/memory/scoped_refptr.h" #include "base/optional.h" #include "cc/paint/frame_metadata.h" #include "cc/paint/image_animation_count.h" #include "cc/paint/paint_export.h" +#include "gpu/command_buffer/common/mailbox.h" #include "third_party/skia/include/core/SkImage.h" #include "third_party/skia/include/core/SkYUVAIndex.h" #include "third_party/skia/include/core/SkYUVASizeInfo.h" @@ -229,8 +229,16 @@ class CC_PAINT_EXPORT PaintImage { const SkYUVASizeInfo& yuva_size_info, SkYUVAIndex* plane_indices) const; + // Returns the SkImage associated with this PaintImage. If PaintImage is + // texture backed, this API may do a readback from GPU to CPU memory. + // Avoid using this API unless actual pixels are needed. + // For other cases, prefer using PaintImage APIs directly or use + // GetSkImageInfo() for metadata about the SkImage. + const sk_sp<SkImage>& GetRasterSkImage() const; + Id stable_id() const { return id_; } const sk_sp<SkImage>& GetSkImage() const; + gpu::Mailbox GetMailbox() const; AnimationType animation_type() const { return animation_type_; } CompletionState completion_state() const { return completion_state_; } bool is_multipart() const { return is_multipart_; } @@ -253,9 +261,7 @@ class CC_PAINT_EXPORT PaintImage { return paint_worklet_input_ ? false : GetSkImage()->isLazyGenerated(); } bool IsPaintWorklet() const { return !!paint_worklet_input_; } - bool IsTextureBacked() const { - return paint_worklet_input_ ? false : GetSkImage()->isTextureBacked(); - } + bool IsTextureBacked() const; int width() const; int height() const; SkColorSpace* color_space() const { diff --git a/chromium/cc/paint/paint_image_builder.h b/chromium/cc/paint/paint_image_builder.h index 25a20bf1a9c..8820b078f5e 100644 --- a/chromium/cc/paint/paint_image_builder.h +++ b/chromium/cc/paint/paint_image_builder.h @@ -43,10 +43,17 @@ class CC_PAINT_EXPORT PaintImageBuilder { PaintImageBuilder&& set_image(sk_sp<SkImage> sk_image, PaintImage::ContentId content_id) { + DCHECK(!sk_image->isTextureBacked()); paint_image_.sk_image_ = std::move(sk_image); paint_image_.content_id_ = content_id; return std::move(*this); } + PaintImageBuilder&& set_texture_backing(sk_sp<TextureBacking> texture_backing, + PaintImage::ContentId content_id) { + paint_image_.texture_backing_ = std::move(texture_backing); + paint_image_.content_id_ = content_id; + return std::move(*this); + } PaintImageBuilder&& set_paint_record(sk_sp<PaintRecord> paint_record, const gfx::Rect& rect, PaintImage::ContentId content_id) { @@ -62,7 +69,6 @@ class CC_PAINT_EXPORT PaintImageBuilder { paint_image_.paint_image_generator_ = std::move(generator); return std::move(*this); } - PaintImageBuilder&& set_animation_type(PaintImage::AnimationType type) { paint_image_.animation_type_ = type; return std::move(*this); @@ -105,19 +111,26 @@ class CC_PAINT_EXPORT PaintImageBuilder { paint_image_.paint_worklet_input_ = std::move(input); return std::move(*this); } - PaintImageBuilder&& set_texture_backing(sk_sp<TextureBacking> texture_backing, - PaintImage::ContentId content_id) { - paint_image_.texture_backing_ = std::move(texture_backing); - paint_image_.content_id_ = content_id; - return std::move(*this); - } PaintImage TakePaintImage(); private: + friend class PaintOpReader; + friend class PaintShader; + friend class ImagePaintFilter; + friend PaintImage CreateNonDiscardablePaintImage(const gfx::Size& size); + PaintImageBuilder(); PaintImageBuilder(PaintImage starting_image, bool clear_contents); + // For GPU process callers using a texture backed SkImage. + PaintImageBuilder&& set_texture_image(sk_sp<SkImage> sk_image, + PaintImage::ContentId content_id) { + paint_image_.sk_image_ = std::move(sk_image); + paint_image_.content_id_ = content_id; + return std::move(*this); + } + PaintImage paint_image_; #if DCHECK_IS_ON() bool id_set_ = false; diff --git a/chromium/cc/paint/paint_op_buffer.cc b/chromium/cc/paint/paint_op_buffer.cc index 51955bcf32f..04963e4d4b4 100644 --- a/chromium/cc/paint/paint_op_buffer.cc +++ b/chromium/cc/paint/paint_op_buffer.cc @@ -315,10 +315,7 @@ size_t SimpleSerialize(const PaintOp* op, void* memory, size_t size) { } PlaybackParams::PlaybackParams(ImageProvider* image_provider) - : image_provider(image_provider), - original_ctm(SkMatrix::I()), - custom_callback(CustomDataRasterCallback()), - did_draw_op_callback(DidDrawOpCallback()) {} + : PlaybackParams(image_provider, SkMatrix::I()) {} PlaybackParams::PlaybackParams(ImageProvider* image_provider, const SkMatrix& original_ctm, @@ -1275,7 +1272,8 @@ void DrawImageOp::RasterWithFlags(const DrawImageOp* op, canvas->scale(1.f / op->scale_adjustment.width(), 1.f / op->scale_adjustment.height()); } - canvas->drawImage(op->image.GetSkImage().get(), op->left, op->top, &paint); + canvas->drawImage(op->image.GetRasterSkImage().get(), op->left, op->top, + &paint); return; } @@ -1342,16 +1340,11 @@ void DrawImageRectOp::RasterWithFlags(const DrawImageRectOp* op, return; } - // TODO(enne): Probably PaintCanvas should just use the skia enum directly. - SkCanvas::SrcRectConstraint skconstraint = - static_cast<SkCanvas::SrcRectConstraint>(op->constraint); - if (!params.image_provider) { SkRect adjusted_src = AdjustSrcRectForScale(op->src, op->scale_adjustment); - flags->DrawToSk(canvas, [op, adjusted_src, skconstraint](SkCanvas* c, - const SkPaint& p) { - c->drawImageRect(op->image.GetSkImage().get(), adjusted_src, op->dst, &p, - skconstraint); + flags->DrawToSk(canvas, [op, adjusted_src](SkCanvas* c, const SkPaint& p) { + c->drawImageRect(op->image.GetRasterSkImage().get(), adjusted_src, + op->dst, &p, op->constraint); }); return; } @@ -1381,12 +1374,12 @@ void DrawImageRectOp::RasterWithFlags(const DrawImageRectOp* op, op->src.makeOffset(decoded_image.src_rect_offset().width(), decoded_image.src_rect_offset().height()); adjusted_src = AdjustSrcRectForScale(adjusted_src, scale_adjustment); - flags->DrawToSk(canvas, [op, &decoded_image, adjusted_src, skconstraint]( - SkCanvas* c, const SkPaint& p) { + flags->DrawToSk(canvas, [op, &decoded_image, adjusted_src](SkCanvas* c, + const SkPaint& p) { SkPaint paint_with_filter_quality(p); paint_with_filter_quality.setFilterQuality(decoded_image.filter_quality()); c->drawImageRect(decoded_image.image().get(), adjusted_src, op->dst, - &paint_with_filter_quality, skconstraint); + &paint_with_filter_quality, op->constraint); }); } @@ -1506,7 +1499,19 @@ void SaveLayerAlphaOp::Raster(const SaveLayerAlphaOp* op, const PlaybackParams& params) { // See PaintOp::kUnsetRect bool unset = op->bounds.left() == SK_ScalarInfinity; - canvas->saveLayerAlpha(unset ? nullptr : &op->bounds, op->alpha); + base::Optional<SkPaint> paint; + if (op->alpha != 0xFF) { + paint.emplace(); + paint->setAlpha(op->alpha); + } + SkCanvas::SaveLayerRec rec(unset ? nullptr : &op->bounds, + base::OptionalOrNullptr(paint)); + if (params.save_layer_alpha_should_preserve_lcd_text.has_value() && + *params.save_layer_alpha_should_preserve_lcd_text) { + rec.fSaveLayerFlags = SkCanvas::kPreserveLCDText_SaveLayerFlag | + SkCanvas::kInitWithPrevious_SaveLayerFlag; + } + canvas->saveLayer(rec); } void ScaleOp::Raster(const ScaleOp* op, @@ -2278,6 +2283,18 @@ bool DrawRecordOp::HasNonAAPaint() const { return record->HasNonAAPaint(); } +bool DrawRecordOp::HasDrawTextOps() const { + return record->has_draw_text_ops(); +} + +bool DrawRecordOp::HasSaveLayerAlphaOps() const { + return record->has_save_layer_alpha_ops(); +} + +bool DrawRecordOp::HasEffectsPreventingLCDTextForSaveLayerAlpha() const { + return record->has_effects_preventing_lcd_text_for_save_layer_alpha(); +} + AnnotateOp::AnnotateOp() : PaintOp(kType) {} AnnotateOp::AnnotateOp(PaintCanvas::AnnotationType annotation_type, @@ -2313,7 +2330,7 @@ DrawImageRectOp::DrawImageRectOp(const PaintImage& image, const SkRect& src, const SkRect& dst, const PaintFlags* flags, - PaintCanvas::SrcRectConstraint constraint) + SkCanvas::SrcRectConstraint constraint) : PaintOpWithFlags(kType, flags ? *flags : PaintFlags()), image(image), src(src), @@ -2389,7 +2406,12 @@ PaintOpBuffer::CompositeIterator::CompositeIterator(CompositeIterator&& other) = default; PaintOpBuffer::PaintOpBuffer() - : has_non_aa_paint_(false), has_discardable_images_(false) {} + : has_non_aa_paint_(false), + has_discardable_images_(false), + has_draw_ops_(false), + has_draw_text_ops_(false), + has_save_layer_alpha_ops_(false), + has_effects_preventing_lcd_text_for_save_layer_alpha_(false) {} PaintOpBuffer::PaintOpBuffer(PaintOpBuffer&& other) { *this = std::move(other); @@ -2409,6 +2431,11 @@ PaintOpBuffer& PaintOpBuffer::operator=(PaintOpBuffer&& other) { subrecord_op_count_ = other.subrecord_op_count_; has_non_aa_paint_ = other.has_non_aa_paint_; has_discardable_images_ = other.has_discardable_images_; + has_draw_ops_ = other.has_draw_ops_; + has_draw_text_ops_ = other.has_draw_text_ops_; + has_save_layer_alpha_ops_ = other.has_save_layer_alpha_ops_; + has_effects_preventing_lcd_text_for_save_layer_alpha_ = + other.has_effects_preventing_lcd_text_for_save_layer_alpha_; // Make sure the other pob can destruct safely. other.used_ = 0; @@ -2430,6 +2457,10 @@ void PaintOpBuffer::Reset() { subrecord_bytes_used_ = 0; subrecord_op_count_ = 0; has_discardable_images_ = false; + has_draw_ops_ = false; + has_draw_text_ops_ = false; + has_save_layer_alpha_ops_ = false; + has_effects_preventing_lcd_text_for_save_layer_alpha_ = false; } // When |op| is a nested PaintOpBuffer, this returns the PaintOp inside @@ -2556,10 +2587,22 @@ void PaintOpBuffer::Playback(SkCanvas* canvas, return; if (offsets && offsets->empty()) return; - // Prevent PaintOpBuffers from having side effects back into the canvas. SkAutoCanvasRestore save_restore(canvas, true); + bool save_layer_alpha_should_preserve_lcd_text = + (!params.save_layer_alpha_should_preserve_lcd_text.has_value() || + *params.save_layer_alpha_should_preserve_lcd_text) && + has_draw_text_ops_ && + !has_effects_preventing_lcd_text_for_save_layer_alpha_; + if (save_layer_alpha_should_preserve_lcd_text) { + // Check if the canvas supports LCD text. + SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType); + canvas->getProps(&props); + if (props.pixelGeometry() == kUnknown_SkPixelGeometry) + save_layer_alpha_should_preserve_lcd_text = false; + } + // TODO(enne): a PaintRecord that contains a SetMatrix assumes that the // SetMatrix is local to that PaintRecord itself. Said differently, if you // translate(x, y), then draw a paint record with a SetMatrix(identity), @@ -2568,6 +2611,8 @@ void PaintOpBuffer::Playback(SkCanvas* canvas, PlaybackParams new_params(params.image_provider, canvas->getTotalMatrix(), params.custom_callback, params.did_draw_op_callback); + new_params.save_layer_alpha_should_preserve_lcd_text = + save_layer_alpha_should_preserve_lcd_text; for (PlaybackFoldingIterator iter(this, offsets); iter; ++iter) { const PaintOp* op = *iter; @@ -2591,10 +2636,6 @@ void PaintOpBuffer::Playback(SkCanvas* canvas, if (const auto* raster_flags = scoped_flags.flags()) flags_op->RasterWithFlags(canvas, raster_flags, new_params); } else { - // TODO(enne): skip SaveLayer followed by restore with nothing in - // between, however SaveLayer with image filters on it (or maybe - // other PaintFlags options) are not a noop. Figure out what these - // are so we can skip them correctly. DCHECK_EQ(iter.alpha(), 255); op->Raster(canvas, new_params); } @@ -2719,4 +2760,18 @@ bool PaintOpBuffer::operator==(const PaintOpBuffer& other) const { return true; } +bool PaintOpBuffer::NeedsAdditionalInvalidationForLCDText( + const PaintOpBuffer& old_buffer) const { + // We need this in addition to blink's raster invalidation because change of + // has_effects_preventing_lcd_text_for_save_layer_alpha() can affect + // all SaveLayerAlphaOps of the PaintOpBuffer, not just the area that the + // changed effects affected. + if (!has_draw_text_ops() || !has_save_layer_alpha_ops()) + return false; + if (!old_buffer.has_draw_text_ops() || !old_buffer.has_save_layer_alpha_ops()) + return false; + return has_effects_preventing_lcd_text_for_save_layer_alpha() != + old_buffer.has_effects_preventing_lcd_text_for_save_layer_alpha(); +} + } // namespace cc diff --git a/chromium/cc/paint/paint_op_buffer.h b/chromium/cc/paint/paint_op_buffer.h index ef564407da9..24459b52dd3 100644 --- a/chromium/cc/paint/paint_op_buffer.h +++ b/chromium/cc/paint/paint_op_buffer.h @@ -12,10 +12,11 @@ #include <type_traits> #include "base/callback.h" +#include "base/check_op.h" #include "base/containers/stack_container.h" #include "base/debug/alias.h" -#include "base/logging.h" #include "base/memory/aligned_memory.h" +#include "base/notreached.h" #include "base/optional.h" #include "cc/base/math_util.h" #include "cc/paint/node_id.h" @@ -124,6 +125,7 @@ struct CC_PAINT_EXPORT PlaybackParams { SkMatrix original_ctm; CustomDataRasterCallback custom_callback; DidDrawOpCallback did_draw_op_callback; + base::Optional<bool> save_layer_alpha_should_preserve_lcd_text; }; class CC_PAINT_EXPORT PaintOp { @@ -252,6 +254,11 @@ class CC_PAINT_EXPORT PaintOp { int CountSlowPathsFromFlags() const { return 0; } bool HasNonAAPaint() const { return false; } + bool HasDrawTextOps() const { return false; } + bool HasSaveLayerAlphaOps() const { return false; } + // Returns true if effects are present that would break LCD text or be broken + // by the flags for SaveLayerAlpha to preserving LCD text. + bool HasEffectsPreventingLCDTextForSaveLayerAlpha() const { return false; } bool HasDiscardableImages() const { return false; } bool HasDiscardableImagesFromFlags() const { return false; } @@ -534,7 +541,7 @@ class CC_PAINT_EXPORT DrawImageRectOp final : public PaintOpWithFlags { const SkRect& src, const SkRect& dst, const PaintFlags* flags, - PaintCanvas::SrcRectConstraint constraint); + SkCanvas::SrcRectConstraint constraint); ~DrawImageRectOp(); static void RasterWithFlags(const DrawImageRectOp* op, const PaintFlags* flags, @@ -552,7 +559,7 @@ class CC_PAINT_EXPORT DrawImageRectOp final : public PaintOpWithFlags { PaintImage image; SkRect src; SkRect dst; - PaintCanvas::SrcRectConstraint constraint; + SkCanvas::SrcRectConstraint constraint; private: DrawImageRectOp(); @@ -672,6 +679,9 @@ class CC_PAINT_EXPORT DrawRecordOp final : public PaintOp { bool HasDiscardableImages() const; int CountSlowPaths() const; bool HasNonAAPaint() const; + bool HasDrawTextOps() const; + bool HasSaveLayerAlphaOps() const; + bool HasEffectsPreventingLCDTextForSaveLayerAlpha() const; HAS_SERIALIZATION_FUNCTIONS(); sk_sp<const PaintRecord> record; @@ -759,6 +769,7 @@ class CC_PAINT_EXPORT DrawTextBlobOp final : public PaintOpWithFlags { SkCanvas* canvas, const PlaybackParams& params); bool IsValid() const { return flags.IsValid(); } + bool HasDrawTextOps() const { return true; } static bool AreEqual(const PaintOp* left, const PaintOp* right); HAS_SERIALIZATION_FUNCTIONS(); @@ -835,6 +846,10 @@ class CC_PAINT_EXPORT SaveLayerOp final : public PaintOpWithFlags { bool IsValid() const { return flags.IsValid() && IsValidOrUnsetRect(bounds); } static bool AreEqual(const PaintOp* left, const PaintOp* right); bool HasNonAAPaint() const { return false; } + // We simply assume any effects (or even no effects -- just starting an empty + // transparent layer) would break LCD text or be broken by the flags for + // SaveLayerAlpha to preserve LCD text. + bool HasEffectsPreventingLCDTextForSaveLayerAlpha() const { return true; } HAS_SERIALIZATION_FUNCTIONS(); SkRect bounds; @@ -853,6 +868,7 @@ class CC_PAINT_EXPORT SaveLayerAlphaOp final : public PaintOp { const PlaybackParams& params); bool IsValid() const { return IsValidOrUnsetRect(bounds); } static bool AreEqual(const PaintOp* left, const PaintOp* right); + bool HasSaveLayerAlphaOps() const { return true; } HAS_SERIALIZATION_FUNCTIONS(); SkRect bounds; @@ -985,6 +1001,16 @@ class CC_PAINT_EXPORT PaintOpBuffer : public SkRefCnt { bool HasNonAAPaint() const { return has_non_aa_paint_; } bool HasDiscardableImages() const { return has_discardable_images_; } + bool has_draw_ops() const { return has_draw_ops_; } + bool has_draw_text_ops() const { return has_draw_text_ops_; } + bool has_save_layer_alpha_ops() const { return has_save_layer_alpha_ops_; } + bool has_effects_preventing_lcd_text_for_save_layer_alpha() const { + return has_effects_preventing_lcd_text_for_save_layer_alpha_; + } + + bool NeedsAdditionalInvalidationForLCDText( + const PaintOpBuffer& old_buffer) const; + bool operator==(const PaintOpBuffer& other) const; bool operator!=(const PaintOpBuffer& other) const { return !(*this == other); @@ -1047,6 +1073,12 @@ class CC_PAINT_EXPORT PaintOpBuffer : public SkRefCnt { subrecord_bytes_used_ += op->AdditionalBytesUsed(); subrecord_op_count_ += op->AdditionalOpCount(); + + has_draw_ops_ |= op->IsDrawOp(); + has_draw_text_ops_ |= op->HasDrawTextOps(); + has_save_layer_alpha_ops_ |= op->HasSaveLayerAlphaOps(); + has_effects_preventing_lcd_text_for_save_layer_alpha_ |= + op->HasEffectsPreventingLCDTextForSaveLayerAlpha(); } template <typename T> @@ -1263,15 +1295,19 @@ class CC_PAINT_EXPORT PaintOpBuffer : public SkRefCnt { size_t reserved_ = 0; size_t op_count_ = 0; - // Record paths for veto-to-msaa for gpu raster. - int num_slow_paths_ = 0; // Record additional bytes used by referenced sub-records and display lists. size_t subrecord_bytes_used_ = 0; // Record total op count of referenced sub-record and display lists. size_t subrecord_op_count_ = 0; + // Record paths for veto-to-msaa for gpu raster. + int num_slow_paths_ = 0; bool has_non_aa_paint_ : 1; bool has_discardable_images_ : 1; + bool has_draw_ops_ : 1; + bool has_draw_text_ops_ : 1; + bool has_save_layer_alpha_ops_ : 1; + bool has_effects_preventing_lcd_text_for_save_layer_alpha_ : 1; }; } // namespace cc diff --git a/chromium/cc/paint/paint_op_buffer_fuzzer.cc b/chromium/cc/paint/paint_op_buffer_fuzzer.cc index 48c7b99140d..3f28f0e8d29 100644 --- a/chromium/cc/paint/paint_op_buffer_fuzzer.cc +++ b/chromium/cc/paint/paint_op_buffer_fuzzer.cc @@ -6,6 +6,7 @@ #include <stdint.h> #include "base/command_line.h" +#include "base/logging.h" #include "base/process/memory.h" #include "base/test/test_discardable_memory_allocator.h" #include "cc/paint/paint_cache.h" diff --git a/chromium/cc/paint/paint_op_buffer_serializer.cc b/chromium/cc/paint/paint_op_buffer_serializer.cc index 7601f978325..3f59290175c 100644 --- a/chromium/cc/paint/paint_op_buffer_serializer.cc +++ b/chromium/cc/paint/paint_op_buffer_serializer.cc @@ -4,13 +4,16 @@ #include "cc/paint/paint_op_buffer_serializer.h" +#include <limits> +#include <memory> +#include <utility> +#include <vector> + #include "base/bind.h" #include "base/trace_event/trace_event.h" #include "cc/paint/scoped_raster_flags.h" #include "ui/gfx/skia_util.h" -#include <utility> - namespace cc { namespace { @@ -72,12 +75,16 @@ PaintOpBufferSerializer::PaintOpBufferSerializer( context_supports_distance_field_text_( context_supports_distance_field_text), max_texture_size_(max_texture_size), - text_blob_canvas_(kMaxExtent, - kMaxExtent, - ComputeSurfaceProps(can_use_lcd_text), - strike_server, - std::move(color_space), - context_supports_distance_field_text) { + text_blob_canvas_( + strike_server + ? std::make_unique<SkTextBlobCacheDiffCanvas>( + kMaxExtent, + kMaxExtent, + ComputeSurfaceProps(can_use_lcd_text), + strike_server, + std::move(color_space), + context_supports_distance_field_text) + : std::make_unique<SkNoDrawCanvas>(kMaxExtent, kMaxExtent)) { DCHECK(serialize_cb_); } @@ -86,16 +93,16 @@ PaintOpBufferSerializer::~PaintOpBufferSerializer() = default; void PaintOpBufferSerializer::Serialize(const PaintOpBuffer* buffer, const std::vector<size_t>* offsets, const Preamble& preamble) { - DCHECK(text_blob_canvas_.getTotalMatrix().isIdentity()); + DCHECK(text_blob_canvas_->getTotalMatrix().isIdentity()); static const int kInitialSaveCount = 1; - DCHECK_EQ(kInitialSaveCount, text_blob_canvas_.getSaveCount()); + DCHECK_EQ(kInitialSaveCount, text_blob_canvas_->getSaveCount()); // These SerializeOptions and PlaybackParams use the initial (identity) canvas // matrix, as they are only used for serializing the preamble and the initial // save / final restore. SerializeBuffer will create its own SerializeOptions // and PlaybackParams based on the post-preamble canvas. PaintOp::SerializeOptions options = MakeSerializeOptions(); - PlaybackParams params = MakeParams(&text_blob_canvas_); + PlaybackParams params = MakeParams(text_blob_canvas_.get()); Save(options, params); SerializePreamble(preamble, options, params); @@ -104,7 +111,7 @@ void PaintOpBufferSerializer::Serialize(const PaintOpBuffer* buffer, } void PaintOpBufferSerializer::Serialize(const PaintOpBuffer* buffer) { - DCHECK(text_blob_canvas_.getTotalMatrix().isIdentity()); + DCHECK(text_blob_canvas_->getTotalMatrix().isIdentity()); SerializeBuffer(buffer, nullptr); } @@ -114,10 +121,10 @@ void PaintOpBufferSerializer::Serialize( const gfx::Rect& playback_rect, const gfx::SizeF& post_scale, const SkMatrix& post_matrix_for_analysis) { - DCHECK(text_blob_canvas_.getTotalMatrix().isIdentity()); + DCHECK(text_blob_canvas_->getTotalMatrix().isIdentity()); PaintOp::SerializeOptions options = MakeSerializeOptions(); - PlaybackParams params = MakeParams(&text_blob_canvas_); + PlaybackParams params = MakeParams(text_blob_canvas_.get()); // TODO(khushalsagar): remove this clip rect if it's not needed. if (!playback_rect.IsEmpty()) { @@ -131,7 +138,7 @@ void PaintOpBufferSerializer::Serialize( SerializeOp(&scale_op, options, params); } - text_blob_canvas_.concat(post_matrix_for_analysis); + text_blob_canvas_->concat(post_matrix_for_analysis); SerializeBuffer(buffer, nullptr); } @@ -208,8 +215,10 @@ void PaintOpBufferSerializer::SerializePreamble( << "full: " << preamble.full_raster_rect.ToString() << ", playback: " << preamble.playback_rect.ToString(); + // NOTE: The following code should be kept consistent with + // RasterSource::PlaybackToCanvas(). bool is_partial_raster = preamble.full_raster_rect != preamble.playback_rect; - if (!preamble.requires_clear) { + if (!preamble.requires_clear && preamble.post_translation.IsZero()) { ClearForOpaqueRaster(preamble, options, params); } else if (!is_partial_raster) { // If rastering the entire tile, clear to transparent pre-clip. This is so @@ -259,7 +268,7 @@ void PaintOpBufferSerializer::SerializeBuffer( const std::vector<size_t>* offsets) { DCHECK(buffer); PaintOp::SerializeOptions options = MakeSerializeOptions(); - PlaybackParams params = MakeParams(&text_blob_canvas_); + PlaybackParams params = MakeParams(text_blob_canvas_.get()); for (PaintOpBuffer::PlaybackFoldingIterator iter(buffer, offsets); iter; ++iter) { @@ -267,13 +276,16 @@ void PaintOpBufferSerializer::SerializeBuffer( // Skip ops outside the current clip if they have images. This saves // performing an unnecessary expensive decode. - const bool skip_op = PaintOp::OpHasDiscardableImages(op) && - PaintOp::QuickRejectDraw(op, &text_blob_canvas_); + bool skip_op = PaintOp::OpHasDiscardableImages(op) && + PaintOp::QuickRejectDraw(op, text_blob_canvas_.get()); + // Skip text ops if there is no SkStrikeServer. + skip_op |= + op->GetType() == PaintOpType::DrawTextBlob && !options.strike_server; if (skip_op) continue; if (op->GetType() == PaintOpType::DrawRecord) { - int save_count = text_blob_canvas_.getSaveCount(); + int save_count = text_blob_canvas_->getSaveCount(); Save(options, params); SerializeBuffer(static_cast<const DrawRecordOp*>(op)->record.get(), nullptr); @@ -290,7 +302,7 @@ void PaintOpBufferSerializer::SerializeBuffer( if (!result || !result.paint_record()) continue; - int save_count = text_blob_canvas_.getSaveCount(); + int save_count = text_blob_canvas_->getSaveCount(); Save(options, params); // The following ops are copying the canvas's ops from // DrawImageRectOp::RasterWithFlags. @@ -387,9 +399,9 @@ void PaintOpBufferSerializer::PlaybackOnAnalysisCanvas( if (op->IsPaintOpWithFlags() && options.flags_to_serialize) { static_cast<const PaintOpWithFlags*>(op)->RasterWithFlags( - &text_blob_canvas_, options.flags_to_serialize, params); + text_blob_canvas_.get(), options.flags_to_serialize, params); } else { - op->Raster(&text_blob_canvas_, params); + op->Raster(text_blob_canvas_.get(), params); } } @@ -404,7 +416,7 @@ void PaintOpBufferSerializer::RestoreToCount( const PaintOp::SerializeOptions& options, const PlaybackParams& params) { RestoreOp restore_op; - while (text_blob_canvas_.getSaveCount() > count) { + while (text_blob_canvas_->getSaveCount() > count) { if (!SerializeOp(&restore_op, options, params)) return; } @@ -412,10 +424,10 @@ void PaintOpBufferSerializer::RestoreToCount( PaintOp::SerializeOptions PaintOpBufferSerializer::MakeSerializeOptions() { return PaintOp::SerializeOptions( - image_provider_, transfer_cache_, paint_cache_, &text_blob_canvas_, + image_provider_, transfer_cache_, paint_cache_, text_blob_canvas_.get(), strike_server_, color_space_, can_use_lcd_text_, context_supports_distance_field_text_, max_texture_size_, - text_blob_canvas_.getTotalMatrix()); + text_blob_canvas_->getTotalMatrix()); } SimpleBufferSerializer::SimpleBufferSerializer( diff --git a/chromium/cc/paint/paint_op_buffer_serializer.h b/chromium/cc/paint/paint_op_buffer_serializer.h index 88eb914af4f..3a57a8039cb 100644 --- a/chromium/cc/paint/paint_op_buffer_serializer.h +++ b/chromium/cc/paint/paint_op_buffer_serializer.h @@ -114,7 +114,7 @@ class CC_PAINT_EXPORT PaintOpBufferSerializer { bool context_supports_distance_field_text_; int max_texture_size_; - SkTextBlobCacheDiffCanvas text_blob_canvas_; + std::unique_ptr<SkNoDrawCanvas> text_blob_canvas_; bool valid_ = true; }; diff --git a/chromium/cc/paint/paint_op_buffer_unittest.cc b/chromium/cc/paint/paint_op_buffer_unittest.cc index 7a2861e76a7..fe73fe73b6b 100644 --- a/chromium/cc/paint/paint_op_buffer_unittest.cc +++ b/chromium/cc/paint/paint_op_buffer_unittest.cc @@ -503,16 +503,16 @@ TEST(PaintOpBufferTest, DiscardableImagesTracking_PaintWorkletImageRect) { SkRect src = SkRect::MakeEmpty(); SkRect dst = SkRect::MakeEmpty(); buffer.push<DrawImageRectOp>(image, src, dst, nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); EXPECT_TRUE(buffer.HasDiscardableImages()); } TEST(PaintOpBufferTest, DiscardableImagesTracking_DrawImageRect) { PaintOpBuffer buffer; PaintImage image = CreateDiscardablePaintImage(gfx::Size(100, 100)); - buffer.push<DrawImageRectOp>( - image, SkRect::MakeWH(100, 100), SkRect::MakeWH(100, 100), nullptr, - PaintCanvas::SrcRectConstraint::kFast_SrcRectConstraint); + buffer.push<DrawImageRectOp>(image, SkRect::MakeWH(100, 100), + SkRect::MakeWH(100, 100), nullptr, + SkCanvas::kFast_SrcRectConstraint); EXPECT_TRUE(buffer.HasDiscardableImages()); } @@ -1081,8 +1081,8 @@ std::vector<uint32_t> test_ids = {0, 1, 56, 0xFFFFFFFF, 0xFFFFFFFE, 0x10001}; std::vector<SkMatrix> test_matrices = { SkMatrix::I(), - SkMatrix::MakeScale(3.91f, 4.31f), - SkMatrix::MakeTrans(-5.2f, 8.7f), + SkMatrix::Scale(3.91f, 4.31f), + SkMatrix::Translate(-5.2f, 8.7f), [] { SkMatrix matrix; SkScalar buffer[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; @@ -1126,7 +1126,7 @@ std::vector<PaintFlags> test_flags = { flags.setBlendMode(SkBlendMode::kDst); flags.setStrokeCap(PaintFlags::kSquare_Cap); flags.setStrokeJoin(PaintFlags::kBevel_Join); - flags.setStyle(PaintFlags::kStrokeAndFill_Style); + flags.setStyle(PaintFlags::kStroke_Style); flags.setFilterQuality(SkFilterQuality::kMedium_SkFilterQuality); flags.setShader(PaintShader::MakeColor(SkColorSetARGB(1, 2, 3, 4))); return flags; @@ -1467,9 +1467,9 @@ void PushDrawImageRectOps(PaintOpBuffer* buffer) { size_t len = std::min({test_images.size(), test_flags.size(), test_rects.size() - 1}); for (size_t i = 0; i < len; ++i) { - PaintCanvas::SrcRectConstraint constraint = - i % 2 ? PaintCanvas::kStrict_SrcRectConstraint - : PaintCanvas::kFast_SrcRectConstraint; + SkCanvas::SrcRectConstraint constraint = + i % 2 ? SkCanvas::kStrict_SrcRectConstraint + : SkCanvas::kFast_SrcRectConstraint; buffer->push<DrawImageRectOp>(test_images[i], test_rects[i], test_rects[i + 1], &test_flags[i], constraint); @@ -1477,8 +1477,7 @@ void PushDrawImageRectOps(PaintOpBuffer* buffer) { // Test optional flags. buffer->push<DrawImageRectOp>(test_images[0], test_rects[0], test_rects[1], - nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + nullptr, SkCanvas::kStrict_SrcRectConstraint); ValidateOps<DrawImageRectOp>(buffer); } @@ -2602,9 +2601,9 @@ TEST(PaintOpBufferTest, ValidateRects) { buffer.push<ClipRectOp>(bad_rect, SkClipOp::kDifference, true); buffer.push<DrawImageRectOp>(test_images[0], bad_rect, test_rects[1], nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); buffer.push<DrawImageRectOp>(test_images[0], test_rects[0], bad_rect, nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); buffer.push<DrawOvalOp>(bad_rect, test_flags[0]); buffer.push<DrawRectOp>(bad_rect, test_flags[0]); buffer.push<SaveLayerOp>(&bad_rect, nullptr); @@ -2925,7 +2924,7 @@ TEST(PaintOpBufferTest, RasterPaintWorkletImageRectBasicCase) { SkRect src = SkRect::MakeXYWH(0, 0, 100, 100); SkRect dst = SkRect::MakeXYWH(0, 0, 100, 100); blink_buffer.push<DrawImageRectOp>(image, src, dst, nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); testing::StrictMock<MockCanvas> canvas; testing::Sequence s; @@ -2967,7 +2966,7 @@ TEST(PaintOpBufferTest, RasterPaintWorkletImageRectTranslated) { SkRect src = SkRect::MakeXYWH(0, 0, 100, 100); SkRect dst = SkRect::MakeXYWH(5, 7, 100, 100); blink_buffer.push<DrawImageRectOp>(image, src, dst, nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); testing::StrictMock<MockCanvas> canvas; testing::Sequence s; @@ -2975,7 +2974,7 @@ TEST(PaintOpBufferTest, RasterPaintWorkletImageRectTranslated) { EXPECT_CALL(canvas, willSave()).InSequence(s); EXPECT_CALL(canvas, OnSaveLayer()).InSequence(s); EXPECT_CALL(canvas, OnSaveLayer()).InSequence(s); - EXPECT_CALL(canvas, didConcat(SkMatrix::MakeTrans(5.0f, 7.0f))); + EXPECT_CALL(canvas, didConcat(SkMatrix::Translate(5.0f, 7.0f))); EXPECT_CALL(canvas, willSave()).InSequence(s); EXPECT_CALL(canvas, didScale(1.0f / scale_adjustment[0].width(), 1.0f / scale_adjustment[0].height())); @@ -3012,7 +3011,7 @@ TEST(PaintOpBufferTest, RasterPaintWorkletImageRectScaled) { SkRect src = SkRect::MakeXYWH(0, 0, 100, 100); SkRect dst = SkRect::MakeXYWH(0, 0, 200, 150); blink_buffer.push<DrawImageRectOp>(image, src, dst, nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); testing::StrictMock<MockCanvas> canvas; testing::Sequence s; @@ -3020,7 +3019,7 @@ TEST(PaintOpBufferTest, RasterPaintWorkletImageRectScaled) { EXPECT_CALL(canvas, willSave()).InSequence(s); EXPECT_CALL(canvas, OnSaveLayer()).InSequence(s); EXPECT_CALL(canvas, OnSaveLayer()).InSequence(s); - EXPECT_CALL(canvas, didConcat(SkMatrix::MakeScale(2.f, 1.5f))); + EXPECT_CALL(canvas, didConcat(SkMatrix::Scale(2.f, 1.5f))); EXPECT_CALL(canvas, willSave()).InSequence(s); EXPECT_CALL(canvas, didScale(1.0f / scale_adjustment[0].width(), 1.0f / scale_adjustment[0].height())); @@ -3060,7 +3059,7 @@ TEST(PaintOpBufferTest, RasterPaintWorkletImageRectClipped) { SkRect src = SkRect::MakeXYWH(0, 0, 20, 20); SkRect dst = SkRect::MakeXYWH(0, 0, 20, 20); blink_buffer.push<DrawImageRectOp>(image, src, dst, nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); testing::StrictMock<MockCanvas> canvas; testing::Sequence s; @@ -3098,9 +3097,8 @@ TEST(PaintOpBufferTest, ReplacesImagesFromProvider) { flags.setFilterQuality(kLow_SkFilterQuality); PaintImage paint_image = CreateDiscardablePaintImage(gfx::Size(10, 10)); buffer.push<DrawImageOp>(paint_image, 0.0f, 0.0f, &flags); - buffer.push<DrawImageRectOp>( - paint_image, rect, rect, &flags, - PaintCanvas::SrcRectConstraint::kFast_SrcRectConstraint); + buffer.push<DrawImageRectOp>(paint_image, rect, rect, &flags, + SkCanvas::kFast_SrcRectConstraint); flags.setShader(PaintShader::MakeImage(paint_image, SkTileMode::kRepeat, SkTileMode::kRepeat, nullptr)); buffer.push<DrawOvalOp>(SkRect::MakeWH(10, 10), flags); @@ -3142,9 +3140,9 @@ TEST(PaintOpBufferTest, DrawImageRectOpWithLooperNoImageProvider) { PaintFlags paint_flags; paint_flags.setLooper(sk_draw_looper_builder.detach()); - buffer.push<DrawImageRectOp>( - image, SkRect::MakeWH(100, 100), SkRect::MakeWH(100, 100), &paint_flags, - PaintCanvas::SrcRectConstraint::kFast_SrcRectConstraint); + buffer.push<DrawImageRectOp>(image, SkRect::MakeWH(100, 100), + SkRect::MakeWH(100, 100), &paint_flags, + SkCanvas::kFast_SrcRectConstraint); testing::StrictMock<MockCanvas> canvas; EXPECT_CALL(canvas, willSave); @@ -3165,9 +3163,9 @@ TEST(PaintOpBufferTest, DrawImageRectOpWithLooperWithImageProvider) { PaintFlags paint_flags; paint_flags.setLooper(sk_draw_looper_builder.detach()); - buffer.push<DrawImageRectOp>( - image, SkRect::MakeWH(100, 100), SkRect::MakeWH(100, 100), &paint_flags, - PaintCanvas::SrcRectConstraint::kFast_SrcRectConstraint); + buffer.push<DrawImageRectOp>(image, SkRect::MakeWH(100, 100), + SkRect::MakeWH(100, 100), &paint_flags, + SkCanvas::kFast_SrcRectConstraint); testing::StrictMock<MockCanvas> canvas; EXPECT_CALL(canvas, willSave); @@ -3192,9 +3190,8 @@ TEST(PaintOpBufferTest, ReplacesImagesFromProviderOOP) { PaintImage paint_image = CreateDiscardablePaintImage(gfx::Size(10, 10)); buffer.push<ScaleOp>(expected_scale.width(), expected_scale.height()); buffer.push<DrawImageOp>(paint_image, 0.0f, 0.0f, &flags); - buffer.push<DrawImageRectOp>( - paint_image, rect, rect, &flags, - PaintCanvas::SrcRectConstraint::kFast_SrcRectConstraint); + buffer.push<DrawImageRectOp>(paint_image, rect, rect, &flags, + SkCanvas::kFast_SrcRectConstraint); flags.setShader(PaintShader::MakeImage(paint_image, SkTileMode::kRepeat, SkTileMode::kRepeat, nullptr)); buffer.push<DrawOvalOp>(SkRect::MakeWH(10, 10), flags); @@ -3558,9 +3555,9 @@ TEST(PaintOpBufferTest, DrawImageRectSerializeScaledImages) { // translations here are arbitrary SkRect src = SkRect::MakeXYWH(3, 4, 20, 6); SkRect dst = SkRect::MakeXYWH(20, 38, 5, 30); - buffer->push<DrawImageRectOp>( - CreateDiscardablePaintImage(gfx::Size(32, 16)), src, dst, nullptr, - PaintCanvas::SrcRectConstraint::kStrict_SrcRectConstraint); + buffer->push<DrawImageRectOp>(CreateDiscardablePaintImage(gfx::Size(32, 16)), + src, dst, nullptr, + SkCanvas::kStrict_SrcRectConstraint); std::unique_ptr<char, base::AlignedFreeDeleter> memory( static_cast<char*>(base::AlignedAlloc(PaintOpBuffer::kInitialBufferSize, @@ -3829,4 +3826,108 @@ TEST(PaintOpBufferTest, NullImages) { PaintOpType::DrawImage); } +TEST(PaintOpBufferTest, HasDrawOpsAndHasDrawTextOps) { + auto buffer1 = sk_make_sp<PaintOpBuffer>(); + EXPECT_FALSE(buffer1->has_draw_ops()); + EXPECT_FALSE(buffer1->has_draw_text_ops()); + buffer1->push<DrawRectOp>(SkRect::MakeWH(3, 4), PaintFlags()); + PushDrawRectOps(buffer1.get()); + EXPECT_TRUE(buffer1->has_draw_ops()); + EXPECT_FALSE(buffer1->has_draw_text_ops()); + + auto buffer2 = sk_make_sp<PaintOpBuffer>(); + EXPECT_FALSE(buffer2->has_draw_ops()); + EXPECT_FALSE(buffer2->has_draw_text_ops()); + buffer2->push<DrawRecordOp>(std::move(buffer1)); + EXPECT_TRUE(buffer2->has_draw_ops()); + EXPECT_FALSE(buffer2->has_draw_text_ops()); + buffer2->push<DrawTextBlobOp>(SkTextBlob::MakeFromString("abc", SkFont()), 0, + 0, PaintFlags()); + EXPECT_TRUE(buffer2->has_draw_ops()); + EXPECT_TRUE(buffer2->has_draw_text_ops()); + buffer2->push<DrawRectOp>(SkRect::MakeWH(4, 5), PaintFlags()); + EXPECT_TRUE(buffer2->has_draw_ops()); + EXPECT_TRUE(buffer2->has_draw_text_ops()); + + auto buffer3 = sk_make_sp<PaintOpBuffer>(); + EXPECT_FALSE(buffer3->has_draw_text_ops()); + EXPECT_FALSE(buffer3->has_draw_ops()); + buffer3->push<DrawRecordOp>(std::move(buffer2)); + EXPECT_TRUE(buffer3->has_draw_ops()); + EXPECT_TRUE(buffer3->has_draw_text_ops()); +} + +TEST(PaintOpBufferTest, HasEffectsPreventingLCDTextForSaveLayerAlpha) { + auto buffer1 = sk_make_sp<PaintOpBuffer>(); + EXPECT_FALSE(buffer1->has_effects_preventing_lcd_text_for_save_layer_alpha()); + buffer1->push<DrawRectOp>(SkRect::MakeWH(3, 4), PaintFlags()); + EXPECT_FALSE(buffer1->has_effects_preventing_lcd_text_for_save_layer_alpha()); + + auto buffer2 = sk_make_sp<PaintOpBuffer>(); + EXPECT_FALSE(buffer2->has_effects_preventing_lcd_text_for_save_layer_alpha()); + buffer2->push<DrawRecordOp>(std::move(buffer1)); + EXPECT_FALSE(buffer2->has_effects_preventing_lcd_text_for_save_layer_alpha()); + buffer2->push<SaveLayerOp>(nullptr, nullptr); + EXPECT_TRUE(buffer2->has_effects_preventing_lcd_text_for_save_layer_alpha()); + buffer2->push<DrawRectOp>(SkRect::MakeWH(4, 5), PaintFlags()); + EXPECT_TRUE(buffer2->has_effects_preventing_lcd_text_for_save_layer_alpha()); + + auto buffer3 = sk_make_sp<PaintOpBuffer>(); + EXPECT_FALSE(buffer3->has_effects_preventing_lcd_text_for_save_layer_alpha()); + buffer3->push<DrawRecordOp>(std::move(buffer2)); + EXPECT_TRUE(buffer3->has_effects_preventing_lcd_text_for_save_layer_alpha()); +} + +TEST(PaintOpBufferTest, NeedsAdditionalInvalidationForLCDText) { + auto buffer1 = sk_make_sp<PaintOpBuffer>(); + buffer1->push<SaveLayerAlphaOp>(nullptr, 100); + EXPECT_FALSE(buffer1->has_draw_text_ops()); + EXPECT_TRUE(buffer1->has_save_layer_alpha_ops()); + EXPECT_FALSE(buffer1->has_effects_preventing_lcd_text_for_save_layer_alpha()); + + auto buffer2 = sk_make_sp<PaintOpBuffer>(); + buffer2->push<DrawTextBlobOp>(SkTextBlob::MakeFromString("abc", SkFont()), 0, + 0, PaintFlags()); + buffer2->push<SaveLayerOp>(nullptr, nullptr); + EXPECT_TRUE(buffer2->has_draw_ops()); + EXPECT_FALSE(buffer2->has_save_layer_alpha_ops()); + EXPECT_TRUE(buffer2->has_effects_preventing_lcd_text_for_save_layer_alpha()); + + // Neither buffer has effects preventing lcd text for SaveLayerAlpha. + EXPECT_FALSE(buffer1->NeedsAdditionalInvalidationForLCDText(*buffer2)); + EXPECT_FALSE(buffer2->NeedsAdditionalInvalidationForLCDText(*buffer1)); + + { + auto buffer3 = sk_make_sp<PaintOpBuffer>(); + buffer3->push<DrawRecordOp>(buffer2); + EXPECT_TRUE( + buffer3->has_effects_preventing_lcd_text_for_save_layer_alpha()); + // Neither buffer has both DrawText and SaveLayerAlpha. + EXPECT_FALSE(buffer1->NeedsAdditionalInvalidationForLCDText(*buffer3)); + EXPECT_FALSE(buffer3->NeedsAdditionalInvalidationForLCDText(*buffer1)); + EXPECT_FALSE(buffer2->NeedsAdditionalInvalidationForLCDText(*buffer3)); + EXPECT_FALSE(buffer3->NeedsAdditionalInvalidationForLCDText(*buffer2)); + } + { + buffer1->push<DrawTextBlobOp>(SkTextBlob::MakeFromString("abc", SkFont()), + 0, 0, PaintFlags()); + EXPECT_TRUE(buffer1->has_draw_text_ops()); + EXPECT_TRUE(buffer1->has_save_layer_alpha_ops()); + EXPECT_FALSE( + buffer1->has_effects_preventing_lcd_text_for_save_layer_alpha()); + auto buffer3 = sk_make_sp<PaintOpBuffer>(); + buffer3->push<DrawRecordOp>(buffer1); + buffer3->push<DrawRecordOp>(buffer2); + EXPECT_TRUE(buffer3->has_draw_text_ops()); + EXPECT_TRUE(buffer3->has_save_layer_alpha_ops()); + EXPECT_TRUE( + buffer3->has_effects_preventing_lcd_text_for_save_layer_alpha()); + // Both have DrawText and SaveLayerAlpha, and have different + // has_effects_preventing_lcd_text_for_save_layer_alpha(). + EXPECT_TRUE(buffer1->NeedsAdditionalInvalidationForLCDText(*buffer3)); + EXPECT_TRUE(buffer3->NeedsAdditionalInvalidationForLCDText(*buffer1)); + EXPECT_FALSE(buffer3->NeedsAdditionalInvalidationForLCDText(*buffer3)); + } +} + } // namespace cc diff --git a/chromium/cc/paint/paint_op_helper_unittest.cc b/chromium/cc/paint/paint_op_helper_unittest.cc index c2682d039b4..3d5db9a8710 100644 --- a/chromium/cc/paint/paint_op_helper_unittest.cc +++ b/chromium/cc/paint/paint_op_helper_unittest.cc @@ -93,7 +93,7 @@ TEST(PaintOpHelper, DrawImageToString) { TEST(PaintOpHelper, DrawImageRectToString) { DrawImageRectOp op(PaintImage(), SkRect::MakeXYWH(1, 2, 3, 4), SkRect::MakeXYWH(5, 6, 7, 8), nullptr, - PaintCanvas::kStrict_SrcRectConstraint); + SkCanvas::kStrict_SrcRectConstraint); std::string str = PaintOpHelper::ToString(&op); EXPECT_EQ( str, diff --git a/chromium/cc/paint/paint_op_reader.cc b/chromium/cc/paint/paint_op_reader.cc index 5118c0f814a..20a06327cb2 100644 --- a/chromium/cc/paint/paint_op_reader.cc +++ b/chromium/cc/paint/paint_op_reader.cc @@ -326,8 +326,8 @@ void PaintOpReader::Read(PaintImage* image) { *image = PaintImageBuilder::WithDefault() .set_id(PaintImage::GetNextId()) - .set_image(SkImage::MakeRasterCopy(pixmap), - PaintImage::kNonLazyStableId) + .set_texture_image(SkImage::MakeRasterCopy(pixmap), + PaintImage::kNonLazyStableId) .TakePaintImage(); } return; @@ -366,10 +366,11 @@ void PaintOpReader::Read(PaintImage* image) { transfer_cache_entry_id)) { if (needs_mips) entry->EnsureMips(); - *image = PaintImageBuilder::WithDefault() - .set_id(PaintImage::GetNextId()) - .set_image(entry->image(), PaintImage::kNonLazyStableId) - .TakePaintImage(); + *image = + PaintImageBuilder::WithDefault() + .set_id(PaintImage::GetNextId()) + .set_texture_image(entry->image(), PaintImage::kNonLazyStableId) + .TakePaintImage(); } } diff --git a/chromium/cc/paint/paint_op_reader.h b/chromium/cc/paint/paint_op_reader.h index 9de213ec7f0..03d9a241c0f 100644 --- a/chromium/cc/paint/paint_op_reader.h +++ b/chromium/cc/paint/paint_op_reader.h @@ -85,10 +85,10 @@ class CC_PAINT_EXPORT PaintOpReader { Read(&value); *type = static_cast<PaintCanvas::AnnotationType>(value); } - void Read(PaintCanvas::SrcRectConstraint* constraint) { + void Read(SkCanvas::SrcRectConstraint* constraint) { uint8_t value = 0u; Read(&value); - *constraint = static_cast<PaintCanvas::SrcRectConstraint>(value); + *constraint = static_cast<SkCanvas::SrcRectConstraint>(value); } void Read(SkFilterQuality* quality) { uint8_t value = 0u; diff --git a/chromium/cc/paint/paint_op_writer.cc b/chromium/cc/paint/paint_op_writer.cc index a24b5c9ffb5..bb59e6feaff 100644 --- a/chromium/cc/paint/paint_op_writer.cc +++ b/chromium/cc/paint/paint_op_writer.cc @@ -243,7 +243,7 @@ void PaintOpWriter::Write(const DrawImage& draw_image, // Security constrained serialization inlines the image bitmap. if (enable_security_constraints_) { SkBitmap bm; - if (!draw_image.paint_image().GetSkImage()->asLegacyBitmap(&bm)) { + if (!draw_image.paint_image().GetRasterSkImage()->asLegacyBitmap(&bm)) { Write(static_cast<uint8_t>(PaintOp::SerializedImageType::kNoImage)); return; } @@ -741,7 +741,7 @@ void PaintOpWriter::Write(const RecordPaintFilter& filter) { SkMatrix mat = options_.canvas->getTotalMatrix(); SkSize scale; if (!mat.isScaleTranslate() && mat.decomposeScale(&scale)) - mat = SkMatrix::MakeScale(scale.width(), scale.height()); + mat = SkMatrix::Scale(scale.width(), scale.height()); Write(filter.record().get(), gfx::Rect(), gfx::SizeF(1.f, 1.f), mat); } diff --git a/chromium/cc/paint/paint_op_writer.h b/chromium/cc/paint/paint_op_writer.h index 187d697796b..cddf8752d2c 100644 --- a/chromium/cc/paint/paint_op_writer.h +++ b/chromium/cc/paint/paint_op_writer.h @@ -69,7 +69,7 @@ class CC_PAINT_EXPORT PaintOpWriter { void Write(PaintCanvas::AnnotationType type) { Write(static_cast<uint8_t>(type)); } - void Write(PaintCanvas::SrcRectConstraint constraint) { + void Write(SkCanvas::SrcRectConstraint constraint) { Write(static_cast<uint8_t>(constraint)); } void Write(SkFilterQuality filter_quality) { diff --git a/chromium/cc/paint/paint_shader.cc b/chromium/cc/paint/paint_shader.cc index 26761e78266..7b55359a9ab 100644 --- a/chromium/cc/paint/paint_shader.cc +++ b/chromium/cc/paint/paint_shader.cc @@ -395,7 +395,8 @@ sk_sp<PaintShader> PaintShader::CreateDecodedImage( decoded_paint_image = PaintImageBuilder::WithDefault() .set_id(image_.stable_id()) - .set_image(std::move(sk_image), image_.GetContentIdForFrame(0u)) + .set_texture_image(std::move(sk_image), + image_.GetContentIdForFrame(0u)) .TakePaintImage(); } diff --git a/chromium/cc/paint/paint_shader_unittest.cc b/chromium/cc/paint/paint_shader_unittest.cc index f18200efb32..66e8768a083 100644 --- a/chromium/cc/paint/paint_shader_unittest.cc +++ b/chromium/cc/paint/paint_shader_unittest.cc @@ -60,13 +60,13 @@ class MockImageProvider : public ImageProvider { } // namespace TEST(PaintShaderTest, RasterizationRectForRecordShaders) { - SkMatrix local_matrix = SkMatrix::MakeScale(0.5f, 0.5f); + SkMatrix local_matrix = SkMatrix::Scale(0.5f, 0.5f); auto record_shader = PaintShader::MakePaintRecord( sk_make_sp<PaintOpBuffer>(), SkRect::MakeWH(100, 100), SkTileMode::kClamp, SkTileMode::kClamp, &local_matrix); SkRect tile_rect; - SkMatrix ctm = SkMatrix::MakeScale(0.5f, 0.5f); + SkMatrix ctm = SkMatrix::Scale(0.5f, 0.5f); EXPECT_TRUE(record_shader->GetRasterizationTileRect(ctm, &tile_rect)); EXPECT_EQ(tile_rect, SkRect::MakeWH(25, 25)); } @@ -85,7 +85,7 @@ TEST(PaintShaderTest, DecodePaintRecord) { .TakePaintImage(); record->push<DrawImageOp>(paint_image, 0.f, 0.f, nullptr); - SkMatrix local_matrix = SkMatrix::MakeScale(0.5f, 0.5f); + SkMatrix local_matrix = SkMatrix::Scale(0.5f, 0.5f); auto record_shader = PaintShader::MakePaintRecord( record, SkRect::MakeWH(100, 100), SkTileMode::kClamp, SkTileMode::kClamp, &local_matrix); @@ -111,7 +111,7 @@ TEST(PaintShaderTest, DecodePaintRecord) { EXPECT_TRUE(skia_image->isLazyGenerated()); EXPECT_EQ(xy[0], record_shader->tx()); EXPECT_EQ(xy[1], record_shader->ty()); - EXPECT_EQ(decoded_local_matrix, SkMatrix::MakeScale(2.f, 2.f)); + EXPECT_EQ(decoded_local_matrix, SkMatrix::Scale(2.f, 2.f)); // The rasterization of the shader is internal to skia, so use a raster canvas // to verify that the decoded paint does not have the encoded image. diff --git a/chromium/cc/paint/record_paint_canvas.cc b/chromium/cc/paint/record_paint_canvas.cc index 09728c8d7de..e8758c76972 100644 --- a/chromium/cc/paint/record_paint_canvas.cc +++ b/chromium/cc/paint/record_paint_canvas.cc @@ -261,7 +261,7 @@ void RecordPaintCanvas::drawImageRect(const PaintImage& image, const SkRect& src, const SkRect& dst, const PaintFlags* flags, - SrcRectConstraint constraint) { + SkCanvas::SrcRectConstraint constraint) { list_->push<DrawImageRectOp>(image, src, dst, flags, constraint); } diff --git a/chromium/cc/paint/record_paint_canvas.h b/chromium/cc/paint/record_paint_canvas.h index cb1396b3b74..4917088a76e 100644 --- a/chromium/cc/paint/record_paint_canvas.h +++ b/chromium/cc/paint/record_paint_canvas.h @@ -8,7 +8,6 @@ #include <memory> #include "base/compiler_specific.h" -#include "base/logging.h" #include "base/optional.h" #include "build/build_config.h" #include "cc/paint/paint_canvas.h" @@ -85,7 +84,7 @@ class CC_PAINT_EXPORT RecordPaintCanvas : public PaintCanvas { const SkRect& src, const SkRect& dst, const PaintFlags* flags, - SrcRectConstraint constraint) override; + SkCanvas::SrcRectConstraint constraint) override; void drawSkottie(scoped_refptr<SkottieWrapper> skottie, const SkRect& dst, float t) override; diff --git a/chromium/cc/paint/scoped_raster_flags_unittest.cc b/chromium/cc/paint/scoped_raster_flags_unittest.cc index 2a4ac36c6e1..1bef28bc3ac 100644 --- a/chromium/cc/paint/scoped_raster_flags_unittest.cc +++ b/chromium/cc/paint/scoped_raster_flags_unittest.cc @@ -131,13 +131,13 @@ TEST(ScopedRasterFlagsTest, ThinAliasedStroke) { uint8_t expect_alpha; } tests[] = { // No downscaling => no stroke change. - {SkMatrix::MakeScale(1.0f, 1.0f), 255, true, false, 1.0f, 0xFF}, + {SkMatrix::Scale(1.0f, 1.0f), 255, true, false, 1.0f, 0xFF}, // Symmetric downscaling => modulated hairline stroke. - {SkMatrix::MakeScale(0.5f, 0.5f), 255, false, false, 0.0f, 0x80}, + {SkMatrix::Scale(0.5f, 0.5f), 255, false, false, 0.0f, 0x80}, // Symmetric downscaling w/ alpha => modulated hairline stroke. - {SkMatrix::MakeScale(0.5f, 0.5f), 127, false, false, 0.0f, 0x40}, + {SkMatrix::Scale(0.5f, 0.5f), 127, false, false, 0.0f, 0x40}, // Anisotropic scaling => AA stroke. - {SkMatrix::MakeScale(0.5f, 1.5f), 255, false, true, 1.0f, 0xFF}, + {SkMatrix::Scale(0.5f, 1.5f), 255, false, true, 1.0f, 0xFF}, }; for (const auto& test : tests) { diff --git a/chromium/cc/paint/skia_paint_canvas.cc b/chromium/cc/paint/skia_paint_canvas.cc index 91d8acc1d52..3e40ebe88cd 100644 --- a/chromium/cc/paint/skia_paint_canvas.cc +++ b/chromium/cc/paint/skia_paint_canvas.cc @@ -274,7 +274,7 @@ void SkiaPaintCanvas::drawImageRect(const PaintImage& image, const SkRect& src, const SkRect& dst, const PaintFlags* flags, - SrcRectConstraint constraint) { + SkCanvas::SrcRectConstraint constraint) { base::Optional<ScopedRasterFlags> scoped_flags; if (flags) { scoped_flags.emplace(flags, image_provider_, canvas_->getTotalMatrix(), diff --git a/chromium/cc/paint/skia_paint_canvas.h b/chromium/cc/paint/skia_paint_canvas.h index 312433f5d77..77870695946 100644 --- a/chromium/cc/paint/skia_paint_canvas.h +++ b/chromium/cc/paint/skia_paint_canvas.h @@ -8,7 +8,6 @@ #include <memory> #include "base/compiler_specific.h" -#include "base/logging.h" #include "build/build_config.h" #include "cc/paint/paint_canvas.h" #include "cc/paint/paint_flags.h" @@ -109,7 +108,7 @@ class CC_PAINT_EXPORT SkiaPaintCanvas final : public PaintCanvas { const SkRect& src, const SkRect& dst, const PaintFlags* flags, - SrcRectConstraint constraint) override; + SkCanvas::SrcRectConstraint constraint) override; void drawSkottie(scoped_refptr<SkottieWrapper> skottie, const SkRect& dst, float t) override; diff --git a/chromium/cc/raster/gpu_raster_buffer_provider.cc b/chromium/cc/raster/gpu_raster_buffer_provider.cc index aec0c26256c..4dbb25b4d81 100644 --- a/chromium/cc/raster/gpu_raster_buffer_provider.cc +++ b/chromium/cc/raster/gpu_raster_buffer_provider.cc @@ -9,6 +9,7 @@ #include <algorithm> #include <utility> +#include "base/logging.h" #include "base/metrics/histogram_macros.h" #include "base/rand_util.h" #include "base/strings/stringprintf.h" diff --git a/chromium/cc/raster/playback_image_provider.cc b/chromium/cc/raster/playback_image_provider.cc index cbda15cb848..103382658e9 100644 --- a/chromium/cc/raster/playback_image_provider.cc +++ b/chromium/cc/raster/playback_image_provider.cc @@ -6,6 +6,7 @@ #include "base/bind.h" #include "cc/tiles/image_decode_cache.h" +#include "gpu/command_buffer/common/mailbox.h" namespace cc { namespace { @@ -57,9 +58,15 @@ ImageProvider::ScopedResult PlaybackImageProvider::GetRasterContent( DrawImage adjusted_image(draw_image, 1.f, frame_index, target_color_space_); if (!cache_->UseCacheForDrawImage(adjusted_image)) { - return ScopedResult(DecodedDrawImage( - paint_image.GetSkImage(), SkSize::Make(0, 0), SkSize::Make(1.f, 1.f), - draw_image.filter_quality(), true /* is_budgeted */)); + if (settings_->use_oop_raster) { + return ScopedResult(DecodedDrawImage(paint_image.GetMailbox(), + draw_image.filter_quality())); + } else { + return ScopedResult( + DecodedDrawImage(paint_image.GetRasterSkImage(), SkSize::Make(0, 0), + SkSize::Make(1.f, 1.f), draw_image.filter_quality(), + true /* is_budgeted */)); + } } auto decoded_draw_image = cache_->GetDecodedImageForDraw(adjusted_image); diff --git a/chromium/cc/raster/playback_image_provider.h b/chromium/cc/raster/playback_image_provider.h index 70991ca2692..1f0f1084fd6 100644 --- a/chromium/cc/raster/playback_image_provider.h +++ b/chromium/cc/raster/playback_image_provider.h @@ -33,6 +33,10 @@ class CC_EXPORT PlaybackImageProvider : public ImageProvider { // The frame index to use for the given image id. If no index is provided, // the frame index provided in the PaintImage will be used. base::flat_map<PaintImage::Id, size_t> image_to_current_frame_index; + + // Indicates that the consumer of decoded images is paint serialization + // for OOP raster. + bool use_oop_raster = false; }; // If no settings are provided, all images are skipped during rasterization. diff --git a/chromium/cc/raster/raster_source.cc b/chromium/cc/raster/raster_source.cc index 99d6d88018a..73ad6fc23ae 100644 --- a/chromium/cc/raster/raster_source.cc +++ b/chromium/cc/raster/raster_source.cc @@ -5,6 +5,7 @@ #include "cc/raster/raster_source.h" #include <stddef.h> +#include <algorithm> #include "base/metrics/histogram_macros.h" #include "base/trace_event/trace_event.h" @@ -102,8 +103,10 @@ void RasterSource::PlaybackToCanvas( // Treat all subnormal values as zero for performance. ScopedSubnormalFloatDisabler disabler; + // NOTE: The following code should be kept consistent with + // PaintOpBufferSerializer::SerializePreamble(). bool is_partial_raster = canvas_bitmap_rect != canvas_playback_rect; - if (!requires_clear_) { + if (!requires_clear_ && raster_transform.translation().IsZero()) { // Clear opaque raster sources. Opaque rasters sources guarantee that all // pixels inside the opaque region are painted. However, due to scaling // it's possible that the last row and column might include pixels that @@ -134,12 +137,13 @@ void RasterSource::PlaybackToCanvas( raster_canvas->clear(SK_ColorTRANSPARENT); } - PlaybackToCanvas(raster_canvas, settings.image_provider); + PlaybackDisplayListToCanvas(raster_canvas, settings.image_provider); raster_canvas->restore(); } -void RasterSource::PlaybackToCanvas(SkCanvas* raster_canvas, - ImageProvider* image_provider) const { +void RasterSource::PlaybackDisplayListToCanvas( + SkCanvas* raster_canvas, + ImageProvider* image_provider) const { // TODO(enne): Temporary CHECK debugging for http://crbug.com/823835 CHECK(display_list_.get()); int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_); diff --git a/chromium/cc/raster/raster_source.h b/chromium/cc/raster/raster_source.h index 7a70742f127..8f7f8679691 100644 --- a/chromium/cc/raster/raster_source.h +++ b/chromium/cc/raster/raster_source.h @@ -56,6 +56,9 @@ class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> { // i.e. contents in the rect will be cropped and translated onto the canvas. // canvas_playback_rect can be used to replay only part of the recording in, // the content space, so only a sub-rect of the tile gets rastered. + // + // Note that this should only be called after the image decode controller has + // been set, which happens during commit. void PlaybackToCanvas(SkCanvas* canvas, const gfx::Size& content_size, const gfx::Rect& canvas_bitmap_rect, @@ -63,17 +66,6 @@ class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> { const gfx::AxisTransform2d& raster_transform, const PlaybackSettings& settings) const; - // Raster this RasterSource into the given canvas. Canvas states such as - // CTM and clip region will be respected. This function will replace pixels - // in the clip region without blending. - // - // Virtual for testing. - // - // Note that this should only be called after the image decode controller has - // been set, which happens during commit. - virtual void PlaybackToCanvas(SkCanvas* canvas, - ImageProvider* image_provider) const; - // Returns whether the given rect at given scale is of solid color in // this raster source, as well as the solid color value. bool PerformSolidColorAnalysis(gfx::Rect content_rect, SkColor* color) const; @@ -139,6 +131,14 @@ class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> { const gfx::Rect& canvas_bitmap_rect, const gfx::Rect& canvas_playback_rect) const; + // Raster the display list of this raster source into the given canvas. + // Canvas states such as CTM and clip region will be respected. + // This function will replace pixels in the clip region without blending. + // + // Virtual for testing. + virtual void PlaybackDisplayListToCanvas(SkCanvas* canvas, + ImageProvider* image_provider) const; + // The serialized size for the largest op in this RasterSource. This is // accessed only on the raster threads with the context lock acquired. size_t max_op_size_hint_ = diff --git a/chromium/cc/raster/scoped_gpu_raster.h b/chromium/cc/raster/scoped_gpu_raster.h index 0ccd91c0259..3d454490bd7 100644 --- a/chromium/cc/raster/scoped_gpu_raster.h +++ b/chromium/cc/raster/scoped_gpu_raster.h @@ -7,7 +7,6 @@ #include <memory> -#include "base/logging.h" #include "cc/cc_export.h" namespace viz { diff --git a/chromium/cc/raster/staging_buffer_pool.cc b/chromium/cc/raster/staging_buffer_pool.cc index fcbe0072eee..556a53615c7 100644 --- a/chromium/cc/raster/staging_buffer_pool.cc +++ b/chromium/cc/raster/staging_buffer_pool.cc @@ -133,9 +133,9 @@ StagingBufferPool::StagingBufferPool( base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( this, "cc::StagingBufferPool", base::ThreadTaskRunnerHandle::Get()); - memory_pressure_listener_.reset(new base::MemoryPressureListener( - base::BindRepeating(&StagingBufferPool::OnMemoryPressure, - weak_ptr_factory_.GetWeakPtr()))); + memory_pressure_listener_ = std::make_unique<base::MemoryPressureListener>( + FROM_HERE, base::BindRepeating(&StagingBufferPool::OnMemoryPressure, + weak_ptr_factory_.GetWeakPtr())); reduce_memory_usage_callback_ = base::BindRepeating( &StagingBufferPool::ReduceMemoryUsage, weak_ptr_factory_.GetWeakPtr()); diff --git a/chromium/cc/raster/task_graph_runner.h b/chromium/cc/raster/task_graph_runner.h index 50c952bf60c..8a43daab03a 100644 --- a/chromium/cc/raster/task_graph_runner.h +++ b/chromium/cc/raster/task_graph_runner.h @@ -13,7 +13,6 @@ #include <memory> #include <vector> -#include "base/logging.h" #include "base/memory/ref_counted.h" #include "cc/cc_export.h" #include "cc/raster/task.h" diff --git a/chromium/cc/resources/resource_pool.cc b/chromium/cc/resources/resource_pool.cc index 6dbfea69d6b..e854ca403b6 100644 --- a/chromium/cc/resources/resource_pool.cc +++ b/chromium/cc/resources/resource_pool.cc @@ -8,6 +8,7 @@ #include <stdint.h> #include <algorithm> +#include <memory> #include <utility> #include "base/atomic_sequence_num.h" @@ -101,9 +102,9 @@ ResourcePool::ResourcePool( clock_(base::DefaultTickClock::GetInstance()) { base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( this, "cc::ResourcePool", task_runner_.get()); - memory_pressure_listener_.reset( - new base::MemoryPressureListener(base::BindRepeating( - &ResourcePool::OnMemoryPressure, weak_ptr_factory_.GetWeakPtr()))); + memory_pressure_listener_ = std::make_unique<base::MemoryPressureListener>( + FROM_HERE, base::BindRepeating(&ResourcePool::OnMemoryPressure, + weak_ptr_factory_.GetWeakPtr())); } ResourcePool::~ResourcePool() { diff --git a/chromium/cc/resources/ui_resource_request.h b/chromium/cc/resources/ui_resource_request.h index 6178fde9094..f70233c85d8 100644 --- a/chromium/cc/resources/ui_resource_request.h +++ b/chromium/cc/resources/ui_resource_request.h @@ -7,7 +7,7 @@ #include <memory> -#include "base/logging.h" +#include "base/check.h" #include "cc/cc_export.h" #include "cc/resources/ui_resource_bitmap.h" #include "cc/resources/ui_resource_client.h" diff --git a/chromium/cc/scheduler/commit_earlyout_reason.h b/chromium/cc/scheduler/commit_earlyout_reason.h index 61c1c93d4c9..4dc8b98462b 100644 --- a/chromium/cc/scheduler/commit_earlyout_reason.h +++ b/chromium/cc/scheduler/commit_earlyout_reason.h @@ -5,7 +5,7 @@ #ifndef CC_SCHEDULER_COMMIT_EARLYOUT_REASON_H_ #define CC_SCHEDULER_COMMIT_EARLYOUT_REASON_H_ -#include "base/logging.h" +#include "base/notreached.h" #include "cc/cc_export.h" namespace cc { diff --git a/chromium/cc/scheduler/scheduler.cc b/chromium/cc/scheduler/scheduler.cc index 445e0696639..8292ee70801 100644 --- a/chromium/cc/scheduler/scheduler.cc +++ b/chromium/cc/scheduler/scheduler.cc @@ -516,20 +516,19 @@ void Scheduler::BeginImplFrameWithDeadline(const viz::BeginFrameArgs& args) { ->BeginMainFrameQueueDurationNotCriticalEstimate(); } - // We defer the invalidation if we expect the main thread to respond within - // this frame, and our prediction in the last frame was correct. That - // is, if we predicted the main thread to be fast and it fails to respond - // before the deadline in the previous frame, we don't defer the invalidation - // in the next frame. - const bool main_thread_response_expected_before_deadline = - bmf_sent_to_ready_to_commit_estimate - time_since_main_frame_sent < - bmf_to_activate_threshold; - const bool previous_invalidation_maybe_skipped_for_main_frame = - state_machine_.should_defer_invalidation_for_fast_main_frame() && - state_machine_.main_thread_failed_to_respond_last_deadline(); + bool main_thread_response_expected_before_deadline; + if (time_since_main_frame_sent > bmf_to_activate_threshold) { + // If the response to a main frame is pending past the desired duration + // then proactively assume that the main thread is slow instead of late + // correction through the frame history. + main_thread_response_expected_before_deadline = false; + } else { + main_thread_response_expected_before_deadline = + bmf_sent_to_ready_to_commit_estimate - time_since_main_frame_sent < + bmf_to_activate_threshold; + } state_machine_.set_should_defer_invalidation_for_fast_main_frame( - main_thread_response_expected_before_deadline && - !previous_invalidation_maybe_skipped_for_main_frame); + main_thread_response_expected_before_deadline); base::TimeDelta bmf_to_activate_estimate = bmf_to_activate_estimate_critical; if (!begin_main_frame_args_.on_critical_path) { @@ -594,7 +593,7 @@ void Scheduler::FinishImplFrame() { DCHECK(!inside_scheduled_action_); { base::AutoReset<bool> mark_inside(&inside_scheduled_action_, true); - client_->DidFinishImplFrame(); + client_->DidFinishImplFrame(last_activate_origin_frame_args()); } if (begin_frame_source_) @@ -745,9 +744,6 @@ void Scheduler::DrawIfPossible() { state_machine_.DidDraw(result); compositor_timing_history_->DidDraw( drawing_with_new_active_tree, - client_->CompositedAnimationsCount(), - client_->MainThreadAnimationsCount(), client_->CurrentFrameHadRAF(), - client_->NextFrameHasPendingRAF(), client_->HasCustomPropertyAnimations()); } @@ -763,9 +759,6 @@ void Scheduler::DrawForced() { state_machine_.DidDraw(result); compositor_timing_history_->DidDraw( drawing_with_new_active_tree, - client_->CompositedAnimationsCount(), - client_->MainThreadAnimationsCount(), client_->CurrentFrameHadRAF(), - client_->NextFrameHasPendingRAF(), client_->HasCustomPropertyAnimations()); } diff --git a/chromium/cc/scheduler/scheduler.h b/chromium/cc/scheduler/scheduler.h index 750e44b4614..0265dc0c3ac 100644 --- a/chromium/cc/scheduler/scheduler.h +++ b/chromium/cc/scheduler/scheduler.h @@ -69,7 +69,13 @@ class SchedulerClient { virtual void ScheduledActionInvalidateLayerTreeFrameSink( bool needs_redraw) = 0; virtual void ScheduledActionPerformImplSideInvalidation() = 0; - virtual void DidFinishImplFrame() = 0; + // Called when the scheduler is done processing a frame. Note that the + // BeginFrameArgs instance passed may not necessarily be the same instance + // that was passed to WillBeginImplFrame(). Rather, |last_activated_args| + // represents the latest BeginFrameArgs instance that caused an activation to + // happen. + virtual void DidFinishImplFrame( + const viz::BeginFrameArgs& last_activated_args) = 0; virtual void DidNotProduceFrame(const viz::BeginFrameAck& ack, FrameSkippedReason reason) = 0; virtual void WillNotReceiveBeginFrame() = 0; @@ -79,11 +85,7 @@ class SchedulerClient { virtual void FrameIntervalUpdated(base::TimeDelta interval) = 0; // Functions used for reporting animation targeting UMA, crbug.com/758439. - virtual size_t CompositedAnimationsCount() const = 0; - virtual size_t MainThreadAnimationsCount() const = 0; virtual bool HasCustomPropertyAnimations() const = 0; - virtual bool CurrentFrameHadRAF() const = 0; - virtual bool NextFrameHasPendingRAF() const = 0; protected: virtual ~SchedulerClient() {} @@ -281,7 +283,8 @@ class CC_EXPORT Scheduler : public viz::BeginFrameObserverBase { // What the latest deadline was, and when it was scheduled. base::TimeTicks deadline_; base::TimeTicks deadline_scheduled_at_; - SchedulerStateMachine::BeginImplFrameDeadlineMode deadline_mode_; + SchedulerStateMachine::BeginImplFrameDeadlineMode deadline_mode_ = + SchedulerStateMachine::BeginImplFrameDeadlineMode::NONE; BeginFrameTracker begin_impl_frame_tracker_; viz::BeginFrameAck last_begin_frame_ack_; diff --git a/chromium/cc/scheduler/scheduler_state_machine.cc b/chromium/cc/scheduler/scheduler_state_machine.cc index e69c54ce465..2dcc5e4bba7 100644 --- a/chromium/cc/scheduler/scheduler_state_machine.cc +++ b/chromium/cc/scheduler/scheduler_state_machine.cc @@ -1191,8 +1191,6 @@ void SchedulerStateMachine::OnBeginImplFrameIdle() { // then the main thread is in a high latency mode. main_thread_missed_last_deadline_ = CommitPending() || has_pending_tree_ || active_tree_needs_first_draw_; - main_thread_failed_to_respond_last_deadline_ = - begin_main_frame_state_ == BeginMainFrameState::SENT; // If we're entering a state where we won't get BeginFrames set all the // funnels so that we don't perform any actions that we shouldn't. diff --git a/chromium/cc/scheduler/scheduler_state_machine.h b/chromium/cc/scheduler/scheduler_state_machine.h index f6a8d0a37f1..97b2571f99e 100644 --- a/chromium/cc/scheduler/scheduler_state_machine.h +++ b/chromium/cc/scheduler/scheduler_state_machine.h @@ -344,10 +344,6 @@ class CC_EXPORT SchedulerStateMachine { return should_defer_invalidation_for_fast_main_frame_; } - bool main_thread_failed_to_respond_last_deadline() const { - return main_thread_failed_to_respond_last_deadline_; - } - protected: bool BeginFrameRequiredForAction() const; bool BeginFrameNeededForVideo() const; @@ -471,10 +467,6 @@ class CC_EXPORT SchedulerStateMachine { // tree. During this time we should not activate the pending tree. bool processing_paint_worklets_for_pending_tree_ = false; - // Set to true if the main thread fails to respond with a commit or abort the - // main frame before the draw deadline on the previous impl frame. - bool main_thread_failed_to_respond_last_deadline_ = false; - bool previous_pending_tree_was_impl_side_ = false; bool current_pending_tree_is_impl_side_ = false; diff --git a/chromium/cc/scheduler/scheduler_unittest.cc b/chromium/cc/scheduler/scheduler_unittest.cc index 4ce0028b0f3..e4be2b3e68b 100644 --- a/chromium/cc/scheduler/scheduler_unittest.cc +++ b/chromium/cc/scheduler/scheduler_unittest.cc @@ -121,7 +121,8 @@ class FakeSchedulerClient : public SchedulerClient, scheduler_->SetNeedsRedraw(); return will_begin_impl_frame_might_have_damage_; } - void DidFinishImplFrame() override { + void DidFinishImplFrame( + const viz::BeginFrameArgs& last_activated_args) override { EXPECT_TRUE(inside_begin_impl_frame_); EXPECT_FALSE(inside_action_); base::AutoReset<bool> mark_inside(&inside_action_, true); @@ -262,11 +263,7 @@ class FakeSchedulerClient : public SchedulerClient, PushAction("RemoveObserver(this)"); } - size_t CompositedAnimationsCount() const override { return 0; } - size_t MainThreadAnimationsCount() const override { return 0; } bool HasCustomPropertyAnimations() const override { return false; } - bool CurrentFrameHadRAF() const override { return false; } - bool NextFrameHasPendingRAF() const override { return false; } protected: bool InsideBeginImplFrameCallback(bool state) { @@ -4361,5 +4358,46 @@ TEST_F(SchedulerTest, SendEarlyDidNotProduceFrameIfIdle) { begin_main_frame_args.frame_id.sequence_number); } +TEST_F(SchedulerTest, + HighImplLatencyModePrioritizesMainFramesOverImplInvalidation) { + scheduler_settings_.enable_main_latency_recovery = false; + scheduler_settings_.enable_impl_latency_recovery = false; + SetUpScheduler(EXTERNAL_BFS); + fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration); + + // Place the impl thread in high latency mode. + scheduler_->SetNeedsImplSideInvalidation(true); + client_->Reset(); + EXPECT_SCOPED(AdvanceFrame()); + EXPECT_ACTIONS("WillBeginImplFrame", + "ScheduledActionPerformImplSideInvalidation"); + + // Request a main frame and start the next impl frame. Since we have an impl + // side pending tree, we will activate and draw it. This finishes the impl + // frame before the main thread can respond causing the scheduler to + // incorrectly assume the main thread is slow. + client_->Reset(); + EXPECT_SCOPED(AdvanceFrame()); + EXPECT_ACTIONS("WillBeginImplFrame"); + client_->Reset(); + scheduler_->SetNeedsBeginMainFrame(); + EXPECT_ACTIONS("ScheduledActionSendBeginMainFrame"); + fake_compositor_timing_history_->SetBeginMainFrameSentTime( + task_runner_->NowTicks() + base::TimeDelta::FromMilliseconds(8)); + client_->Reset(); + scheduler_->NotifyReadyToActivate(); + task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true)); + EXPECT_ACTIONS("ScheduledActionActivateSyncTree", + "ScheduledActionDrawIfPossible"); + + // Start a new frame. We should not assume the main thread is slow. + client_->Reset(); + EXPECT_SCOPED(AdvanceFrame()); + scheduler_->SetNeedsImplSideInvalidation(true); + // No invalidation should be performed since we are waiting for the main + // thread to respond and merge with the commit. + EXPECT_ACTIONS("WillBeginImplFrame"); +} + } // namespace } // namespace cc diff --git a/chromium/cc/tiles/checker_image_tracker.cc b/chromium/cc/tiles/checker_image_tracker.cc index 8495b03dda1..4c932e98d61 100644 --- a/chromium/cc/tiles/checker_image_tracker.cc +++ b/chromium/cc/tiles/checker_image_tracker.cc @@ -4,6 +4,8 @@ #include "cc/tiles/checker_image_tracker.h" +#include <sstream> + #include "base/bind.h" #include "base/metrics/histogram_macros.h" #include "base/stl_util.h" @@ -407,8 +409,7 @@ void CheckerImageTracker::ScheduleNextImageDecode() { draw_image = DrawImage( candidate, SkIRect::MakeWH(candidate.width(), candidate.height()), it->second.filter_quality, - SkMatrix::MakeScale(it->second.scale.width(), - it->second.scale.height()), + SkMatrix::Scale(it->second.scale.width(), it->second.scale.height()), it->second.frame_index, it->second.color_space); outstanding_image_decode_.emplace(candidate); break; diff --git a/chromium/cc/tiles/checker_image_tracker_unittest.cc b/chromium/cc/tiles/checker_image_tracker_unittest.cc index 57984cc8d00..100e27a77d2 100644 --- a/chromium/cc/tiles/checker_image_tracker_unittest.cc +++ b/chromium/cc/tiles/checker_image_tracker_unittest.cc @@ -470,7 +470,7 @@ TEST_F(CheckerImageTrackerTest, ChoosesMaxScaleAndQuality) { gfx::ColorSpace()); DrawImage scaled_image2 = DrawImage(image.paint_image(), image.src_rect(), kHigh_SkFilterQuality, - SkMatrix::MakeScale(1.8f), PaintImage::kDefaultFrameIndex, + SkMatrix::Scale(1.8f, 1.8f), PaintImage::kDefaultFrameIndex, gfx::ColorSpace()); std::vector<DrawImage> draw_images = {scaled_image1, scaled_image2}; diff --git a/chromium/cc/tiles/gpu_image_decode_cache.cc b/chromium/cc/tiles/gpu_image_decode_cache.cc index 4a2d6586f27..1ed44f98cb2 100644 --- a/chromium/cc/tiles/gpu_image_decode_cache.cc +++ b/chromium/cc/tiles/gpu_image_decode_cache.cc @@ -16,6 +16,7 @@ #include "base/debug/alias.h" #include "base/feature_list.h" #include "base/hash/hash.h" +#include "base/logging.h" #include "base/memory/discardable_memory_allocator.h" #include "base/metrics/histogram_macros.h" #include "base/numerics/safe_math.h" @@ -1043,9 +1044,9 @@ GpuImageDecodeCache::GpuImageDecodeCache( base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider( this, "cc::GpuImageDecodeCache", base::ThreadTaskRunnerHandle::Get()); } - memory_pressure_listener_.reset( - new base::MemoryPressureListener(base::BindRepeating( - &GpuImageDecodeCache::OnMemoryPressure, base::Unretained(this)))); + memory_pressure_listener_ = std::make_unique<base::MemoryPressureListener>( + FROM_HERE, base::BindRepeating(&GpuImageDecodeCache::OnMemoryPressure, + base::Unretained(this))); } GpuImageDecodeCache::~GpuImageDecodeCache() { @@ -1164,7 +1165,12 @@ ImageDecodeCache::TaskResult GpuImageDecodeCache::GetTaskForImageAndRefInternal( task = GetImageDecodeTaskAndRef(draw_image, tracing_info, task_type); } - return TaskResult(task, + if (task) { + return TaskResult(task, + image_data->decode.can_do_hardware_accelerated_decode()); + } + + return TaskResult(true /* needs_unref */, false /* is_at_raster_decode */, image_data->decode.can_do_hardware_accelerated_decode()); } @@ -1922,7 +1928,8 @@ void GpuImageDecodeCache::DecodeImageIfNecessary(const DrawImage& draw_image, DLOG(ERROR) << "YUV + Bitmap is unknown and unimplemented!"; NOTREACHED(); } else { - image_data->decode.SetBitmapImage(draw_image.paint_image().GetSkImage()); + image_data->decode.SetBitmapImage( + draw_image.paint_image().GetRasterSkImage()); } return; } @@ -2086,7 +2093,7 @@ void GpuImageDecodeCache::UploadImageIfNecessary(const DrawImage& draw_image, // Get the encoded data in a contiguous form. sk_sp<SkData> encoded_data = - draw_image.paint_image().GetSkImage()->refEncodedData(); + draw_image.paint_image().GetRasterSkImage()->refEncodedData(); DCHECK(encoded_data); const uint32_t transfer_cache_id = ClientImageTransferCacheEntry::GetNextId(); @@ -2526,7 +2533,7 @@ void GpuImageDecodeCache::FlushYUVImages( CheckContextLockAcquiredIfNecessary(); lock_.AssertAcquired(); for (auto& image : *yuv_images) { - image->flush(context_->GrContext()); + image->flushAndSubmit(context_->GrContext()); } yuv_images->clear(); } diff --git a/chromium/cc/tiles/gpu_image_decode_cache.h b/chromium/cc/tiles/gpu_image_decode_cache.h index 4ee3ae8054e..7c345dbbbd5 100644 --- a/chromium/cc/tiles/gpu_image_decode_cache.h +++ b/chromium/cc/tiles/gpu_image_decode_cache.h @@ -11,6 +11,7 @@ #include <vector> #include "base/containers/mru_cache.h" +#include "base/logging.h" #include "base/memory/discardable_memory.h" #include "base/memory/memory_pressure_listener.h" #include "base/optional.h" diff --git a/chromium/cc/tiles/gpu_image_decode_cache_perftest.cc b/chromium/cc/tiles/gpu_image_decode_cache_perftest.cc index 7a9039099bb..416cd8233c8 100644 --- a/chromium/cc/tiles/gpu_image_decode_cache_perftest.cc +++ b/chromium/cc/tiles/gpu_image_decode_cache_perftest.cc @@ -157,7 +157,7 @@ TEST_P(GpuImageDecodeCachePerfTestNoSw, DecodeWithMips) { surface->getCanvas()->drawImageRect(decoded_image.image().get(), SkRect::MakeWH(1024, 2048), SkRect::MakeWH(614, 1229), &paint); - surface->flush(); + surface->flushAndSubmit(); } cache_->DrawWithImageFinished(image, decoded_image); diff --git a/chromium/cc/tiles/gpu_image_decode_cache_unittest.cc b/chromium/cc/tiles/gpu_image_decode_cache_unittest.cc index 3ed5b0b5b94..3c9db3a438e 100644 --- a/chromium/cc/tiles/gpu_image_decode_cache_unittest.cc +++ b/chromium/cc/tiles/gpu_image_decode_cache_unittest.cc @@ -429,7 +429,6 @@ class GpuImageDecodeCacheTest } PaintImage CreateBitmapImageInternal(const gfx::Size& size) { - DCHECK(!do_yuv_decode_); return CreateBitmapImage(size, color_type_); } @@ -2928,6 +2927,20 @@ TEST_P(GpuImageDecodeCacheTest, GetBorderlineLargeDecodedImageForDraw) { cache->UnrefImage(draw_image); } +TEST_P(GpuImageDecodeCacheTest, OutOfRasterDecodeForBitmaps) { + auto cache = CreateCache(); + + PaintImage image = CreateBitmapImageInternal(GetNormalImageSize()); + DrawImage draw_image = CreateDrawImageInternal(image); + ImageDecodeCache::TaskResult result = + cache->GetOutOfRasterDecodeTaskForImageAndRef(draw_image); + EXPECT_TRUE(result.need_unref); + EXPECT_FALSE(result.task); + EXPECT_FALSE(result.is_at_raster_decode); + EXPECT_FALSE(result.can_do_hardware_accelerated_decode); + cache->UnrefImage(draw_image); +} + SkColorType test_color_types[] = {kN32_SkColorType, kARGB_4444_SkColorType, kRGBA_F16_SkColorType}; bool false_array[] = {false}; diff --git a/chromium/cc/tiles/image_controller_unittest.cc b/chromium/cc/tiles/image_controller_unittest.cc index fbe924af6fd..06da97ecd4b 100644 --- a/chromium/cc/tiles/image_controller_unittest.cc +++ b/chromium/cc/tiles/image_controller_unittest.cc @@ -202,7 +202,7 @@ class BlockingTask : public TileTask { EXPECT_FALSE(HasCompleted()); EXPECT_FALSE(thread_checker_.CalledOnValidThread()); base::AutoLock hold(lock_); - if (!can_run_) + while (!can_run_) run_cv_.Wait(); has_run_ = true; } diff --git a/chromium/cc/tiles/image_decode_cache.h b/chromium/cc/tiles/image_decode_cache.h index 6366a6276f6..bd77daad149 100644 --- a/chromium/cc/tiles/image_decode_cache.h +++ b/chromium/cc/tiles/image_decode_cache.h @@ -77,11 +77,24 @@ class CC_EXPORT ImageDecodeCache { ToScopedImageType(ImageType image_type) { using ScopedImageType = devtools_instrumentation::ScopedImageDecodeTask::ImageType; - if (image_type == ImageType::kWEBP) - return ScopedImageType::kWebP; - if (image_type == ImageType::kJPEG) - return ScopedImageType::kJpeg; - return ScopedImageType::kOther; + switch (image_type) { + case ImageType::kAVIF: + return ScopedImageType::kAvif; + case ImageType::kBMP: + return ScopedImageType::kBmp; + case ImageType::kGIF: + return ScopedImageType::kGif; + case ImageType::kICO: + return ScopedImageType::kIco; + case ImageType::kJPEG: + return ScopedImageType::kJpeg; + case ImageType::kPNG: + return ScopedImageType::kPng; + case ImageType::kWEBP: + return ScopedImageType::kWebP; + case ImageType::kInvalid: + return ScopedImageType::kOther; + } } virtual ~ImageDecodeCache() {} diff --git a/chromium/cc/tiles/software_image_decode_cache.cc b/chromium/cc/tiles/software_image_decode_cache.cc index c674a447206..412c1b02c3c 100644 --- a/chromium/cc/tiles/software_image_decode_cache.cc +++ b/chromium/cc/tiles/software_image_decode_cache.cc @@ -82,7 +82,7 @@ class SoftwareImageDecodeTaskImpl : public TileTask { const ImageType image_type = image_metadata ? image_metadata->image_type : ImageType::kInvalid; devtools_instrumentation::ScopedImageDecodeTask image_decode_task( - paint_image_.GetSkImage().get(), + paint_image_.GetRasterSkImage().get(), devtools_instrumentation::ScopedImageDecodeTask::kSoftware, ImageDecodeCache::ToScopedTaskType(tracing_info_.task_type), ImageDecodeCache::ToScopedImageType(image_type)); @@ -134,24 +134,6 @@ SkFilterQuality GetDecodedFilterQuality( : kLow_SkFilterQuality; } -void RecordLockExistingCachedImageHistogram(TilePriority::PriorityBin bin, - bool success) { - switch (bin) { - case TilePriority::NOW: - UMA_HISTOGRAM_BOOLEAN("Renderer4.LockExistingCachedImage.Software.NOW", - success); - break; - case TilePriority::SOON: - UMA_HISTOGRAM_BOOLEAN("Renderer4.LockExistingCachedImage.Software.SOON", - success); - break; - case TilePriority::EVENTUALLY: - UMA_HISTOGRAM_BOOLEAN( - "Renderer4.LockExistingCachedImage.Software.EVENTUALLY", success); - break; - } -} - } // namespace SoftwareImageDecodeCache::SoftwareImageDecodeCache( @@ -357,9 +339,6 @@ SoftwareImageDecodeCache::DecodeImageIfNecessary(const CacheKey& key, return TaskProcessingResult::kLockOnly; bool lock_succeeded = entry->Lock(); - // TODO(vmpstr): Deprecate the prepaint split, since it doesn't matter. - RecordLockExistingCachedImageHistogram(TilePriority::NOW, lock_succeeded); - if (lock_succeeded) return TaskProcessingResult::kLockOnly; } diff --git a/chromium/cc/tiles/software_image_decode_cache_utils.cc b/chromium/cc/tiles/software_image_decode_cache_utils.cc index cfd2e8786cf..5cbb20aba61 100644 --- a/chromium/cc/tiles/software_image_decode_cache_utils.cc +++ b/chromium/cc/tiles/software_image_decode_cache_utils.cc @@ -5,6 +5,7 @@ #include "cc/tiles/software_image_decode_cache_utils.h" #include <algorithm> +#include <sstream> #include <utility> #include "base/atomic_sequence_num.h" diff --git a/chromium/cc/tiles/tile_priority.cc b/chromium/cc/tiles/tile_priority.cc index 606a8c64e0b..1bfe552c057 100644 --- a/chromium/cc/tiles/tile_priority.cc +++ b/chromium/cc/tiles/tile_priority.cc @@ -11,18 +11,6 @@ namespace cc { -std::string WhichTreeToString(WhichTree tree) { - switch (tree) { - case ACTIVE_TREE: - return "ACTIVE_TREE"; - case PENDING_TREE: - return "PENDING_TREE"; - default: - DCHECK(false) << "Unrecognized WhichTree value " << tree; - return "<unknown WhichTree value>"; - } -} - std::string TileResolutionToString(TileResolution resolution) { switch (resolution) { case LOW_RESOLUTION: diff --git a/chromium/cc/tiles/tile_priority.h b/chromium/cc/tiles/tile_priority.h index 34cd3bc0c5d..bffd8d8ee40 100644 --- a/chromium/cc/tiles/tile_priority.h +++ b/chromium/cc/tiles/tile_priority.h @@ -16,10 +16,6 @@ #include "cc/cc_export.h" #include "third_party/perfetto/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.pbzero.h" -namespace base { -class Value; -} - namespace cc { enum WhichTree { @@ -28,9 +24,7 @@ enum WhichTree { ACTIVE_TREE = 0, PENDING_TREE = 1, LAST_TREE = 1 - // Be sure to update WhichTreeAsValue when adding new fields. }; -std::unique_ptr<base::Value> WhichTreeAsValue(WhichTree tree); enum TileResolution { LOW_RESOLUTION = 0 , diff --git a/chromium/cc/trees/damage_tracker_unittest.cc b/chromium/cc/trees/damage_tracker_unittest.cc index cc784ab1213..db9fcc1fcf6 100644 --- a/chromium/cc/trees/damage_tracker_unittest.cc +++ b/chromium/cc/trees/damage_tracker_unittest.cc @@ -236,6 +236,23 @@ class DamageTrackerTest : public LayerTreeImplTestBase, public testing::Test { return root; } + LayerImpl* CreateAndSetUpTestTreeWithTwoSurfacesDrawingFullyVisible() { + LayerImpl* root = CreateTestTreeWithTwoSurfaces(); + // Make sure render surface takes content outside visible rect into + // consideration. + root->layer_tree_impl() + ->property_trees() + ->effect_tree.Node(child1_->effect_tree_index()) + ->backdrop_filters.Append( + FilterOperation::CreateZoomFilter(2.f /* zoom */, 0 /* inset */)); + + // Setup includes going past the first frame which always damages + // everything, so that we can actually perform specific tests. + EmulateDrawingOneFrame(root); + + return root; + } + LayerImpl* CreateAndSetUpTestTreeWithFourSurfaces() { LayerImpl* root = CreateTestTreeWithFourSurfaces(); @@ -1833,7 +1850,7 @@ TEST_F(DamageTrackerTest, DamageRectTooBigWithFilter) { } TEST_F(DamageTrackerTest, DamageRectTooBigInRenderSurface) { - LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces(); + LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfacesDrawingFullyVisible(); // Really far left. grand_child1_->SetOffsetToTransformParent( diff --git a/chromium/cc/trees/draw_properties_unittest.cc b/chromium/cc/trees/draw_properties_unittest.cc index 6abe4863df5..b19a402d142 100644 --- a/chromium/cc/trees/draw_properties_unittest.cc +++ b/chromium/cc/trees/draw_properties_unittest.cc @@ -12,6 +12,7 @@ #include "base/memory/ptr_util.h" #include "base/stl_util.h" +#include "base/test/scoped_feature_list.h" #include "cc/animation/animation.h" #include "cc/animation/animation_host.h" #include "cc/animation/animation_id_provider.h" @@ -1415,10 +1416,13 @@ TEST_F(DrawPropertiesTest, DrawableContentRectForLayers) { UpdateActiveTreeDrawProperties(); - EXPECT_EQ(gfx::Rect(5, 5, 10, 10), grand_child1->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect()); - EXPECT_TRUE(grand_child4->drawable_content_rect().IsEmpty()); + EXPECT_EQ(gfx::Rect(5, 5, 10, 10), + grand_child1->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(15, 15, 5, 5), + grand_child3->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(15, 15, 5, 5), + grand_child3->visible_drawable_content_rect()); + EXPECT_TRUE(grand_child4->visible_drawable_content_rect().IsEmpty()); } TEST_F(DrawPropertiesTest, ClipRectIsPropagatedCorrectlyToSurfaces) { @@ -1775,7 +1779,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsForIdentityTransform) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); // Case 2: Layer is outside the surface rect. layer_content_rect = gfx::Rect(120, 120, 30, 30); @@ -1785,7 +1789,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsForIdentityTransform) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); // Case 3: Layer is partially overlapping the surface rect. layer_content_rect = gfx::Rect(80, 80, 30, 30); @@ -1795,7 +1799,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsForIdentityTransform) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); } // Test visible layer rect and drawable content rect are calculated correctly @@ -1815,7 +1819,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor2DRotations) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); // Case 2: Layer is outside the surface rect. layer_to_surface_transform.MakeIdentity(); @@ -1827,7 +1831,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor2DRotations) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); // Case 3: The layer is rotated about its top-left corner. In surface space, // the layer is oriented diagonally, with the left half outside of the render @@ -1842,7 +1846,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor2DRotations) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); // Case 4: The layer is rotated about its top-left corner, and translated // upwards. In surface space, the layer is oriented diagonally, with only the @@ -1859,7 +1863,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor2DRotations) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); } // Test visible layer rect and drawable content rect are calculated correctly @@ -1880,7 +1884,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor3dOrthographicTransform) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); // Case 2: Orthographic projection of a layer rotated about y-axis by 45 // degrees, but shifted to the side so only the right-half the layer would be @@ -1899,7 +1903,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor3dOrthographicTransform) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); } // Test visible layer rect and drawable content rect are calculated correctly @@ -1931,7 +1935,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor3dPerspectiveTransform) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); // Case 2: same projection as before, except that the layer is also translated // to the side, so that only the right half of the layer should be visible. @@ -1951,7 +1955,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor3dPerspectiveTransform) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); } // There is currently no explicit concept of an orthographic projection plane @@ -1979,7 +1983,7 @@ TEST_F(DrawPropertiesDrawRectsTest, target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); } // Test visible layer rect and drawable content rect are calculated correctly @@ -2018,7 +2022,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsFor3dPerspectiveWhenClippedByW) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); } static bool ProjectionClips(const gfx::Transform& map_transform, @@ -2070,7 +2074,7 @@ TEST_F(DrawPropertiesDrawRectsTest, DrawRectsForPerspectiveUnprojection) { target_surface_rect, layer_to_surface_transform, layer_content_rect); EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect()); EXPECT_EQ(expected_drawable_content_rect, - drawing_layer->drawable_content_rect()); + drawing_layer->visible_drawable_content_rect()); } TEST_F(DrawPropertiesTest, DrawableAndVisibleContentRectsForSimpleLayers) { @@ -2106,10 +2110,14 @@ TEST_F(DrawPropertiesTest, DrawableAndVisibleContentRectsForSimpleLayers) { EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2_layer->visible_layer_rect()); EXPECT_TRUE(child3_layer->visible_layer_rect().IsEmpty()); - // layer drawable_content_rects are not clipped. - EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1_layer->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2_layer->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3_layer->drawable_content_rect()); + // layer visible_drawable_content_rects are in target space, but still only + // the visible part. + EXPECT_EQ(gfx::Rect(0, 0, 50, 50), + child1_layer->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(75, 75, 25, 25), + child2_layer->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(125, 125, 0, 0), + child3_layer->visible_drawable_content_rect()); } TEST_F(DrawPropertiesTest, @@ -2153,9 +2161,11 @@ TEST_F(DrawPropertiesTest, EXPECT_TRUE(grand_child3->visible_layer_rect().IsEmpty()); // All grandchild DrawableContentRects should also be clipped by child. - EXPECT_EQ(gfx::Rect(5, 5, 50, 50), grand_child1->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(75, 75, 25, 25), grand_child2->drawable_content_rect()); - EXPECT_TRUE(grand_child3->drawable_content_rect().IsEmpty()); + EXPECT_EQ(gfx::Rect(5, 5, 50, 50), + grand_child1->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(75, 75, 25, 25), + grand_child2->visible_drawable_content_rect()); + EXPECT_TRUE(grand_child3->visible_drawable_content_rect().IsEmpty()); } TEST_F(DrawPropertiesTest, VisibleContentRectWithClippingAndScaling) { @@ -2286,7 +2296,7 @@ TEST_F(DrawPropertiesTest, // An unclipped surface grows its DrawableContentRect to include all drawable // regions of the subtree. - EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f), + EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f), GetRenderSurface(render_surface)->DrawableContentRect()); // All layers that draw content into the unclipped surface are also unclipped. @@ -2295,9 +2305,9 @@ TEST_F(DrawPropertiesTest, EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect()); EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child3->visible_layer_rect()); - EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect()); + EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(75, 75, 25, 25), child2->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(125, 125, 0, 0), child3->visible_drawable_content_rect()); } TEST_F(DrawPropertiesTest, VisibleContentRectsForClippedSurfaceWithEmptyClip) { @@ -2361,7 +2371,7 @@ TEST_F(DrawPropertiesTest, UpdateActiveTreeDrawProperties(); EXPECT_TRUE(child->visible_layer_rect().IsEmpty()); - EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); + EXPECT_TRUE(child->visible_drawable_content_rect().IsEmpty()); // Case 2: a matrix with flattened z, uninvertible and not visible according // to the CSS spec. @@ -2373,7 +2383,7 @@ TEST_F(DrawPropertiesTest, UpdateActiveTreeDrawProperties(); EXPECT_TRUE(child->visible_layer_rect().IsEmpty()); - EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); + EXPECT_TRUE(child->visible_drawable_content_rect().IsEmpty()); // Case 3: a matrix with flattened z, also uninvertible and not visible. uninvertible_matrix.MakeIdentity(); @@ -2385,7 +2395,7 @@ TEST_F(DrawPropertiesTest, UpdateActiveTreeDrawProperties(); EXPECT_TRUE(child->visible_layer_rect().IsEmpty()); - EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); + EXPECT_TRUE(child->visible_drawable_content_rect().IsEmpty()); } TEST_F(DrawPropertiesTest, @@ -2592,10 +2602,11 @@ TEST_F(DrawPropertiesTest, EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect()); EXPECT_TRUE(child3->visible_layer_rect().IsEmpty()); - // But the DrawableContentRects are unclipped. - EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect()); + // The visible_drawable_content_rect would be the visible rect in target + // space. + EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(75, 75, 25, 25), child2->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(125, 125, 0, 0), child3->visible_drawable_content_rect()); } // Check that clipping does not propagate down surfaces. @@ -2651,8 +2662,9 @@ TEST_F(DrawPropertiesTest, DrawableAndVisibleContentRectsForSurfaceHierarchy) { // render_surface1 lives in the "unclipped universe" of render_surface1, and // is only implicitly clipped by render_surface1's content rect. So, - // render_surface2 grows to enclose all drawable content of its subtree. - EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f), + // render_surface2 grows to enclose all visible drawable content of its + // subtree. + EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f), GetRenderSurface(render_surface2)->DrawableContentRect()); // All layers that draw content into render_surface2 think they are unclipped @@ -2662,9 +2674,9 @@ TEST_F(DrawPropertiesTest, DrawableAndVisibleContentRectsForSurfaceHierarchy) { EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child3->visible_layer_rect()); // DrawableContentRects are also unclipped. - EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect()); + EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(75, 75, 25, 25), child2->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(125, 125, 0, 0), child3->visible_drawable_content_rect()); } TEST_F(DrawPropertiesTest, @@ -2943,7 +2955,8 @@ TEST_F(DrawPropertiesTest, // All layers that draw content into the unclipped surface are also unclipped. EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect()); - EXPECT_EQ(expected_surface_drawable_content, child1->drawable_content_rect()); + EXPECT_EQ(expected_surface_drawable_content, + child1->visible_drawable_content_rect()); } // Layers that have non-axis aligned bounds (due to transforms) have an @@ -2967,6 +2980,14 @@ TEST_F(DrawPropertiesTest, CreateEffectNode(render_surface).render_surface_reason = RenderSurfaceReason::kTest; CopyProperties(render_surface, child1); + // Make sure render surface takes content outside visible rect into + // consideration. + root->layer_tree_impl() + ->property_trees() + ->effect_tree.Node(child1->effect_tree_index()) + ->backdrop_filters.Append( + FilterOperation::CreateZoomFilter(1.f /* zoom */, 0 /* inset */)); + auto& child1_transform_node = CreateTransformNode(child1); child1_transform_node.origin = gfx::Point3F(25.f, 25.f, 0.f); child1_transform_node.post_translation = gfx::Vector2dF(25.f, 25.f); @@ -2993,7 +3014,7 @@ TEST_F(DrawPropertiesTest, EXPECT_EQ(gfx::Rect(0, 0, 25, 50), child1->visible_layer_rect()); // The child's DrawableContentRect is unclipped. - EXPECT_EQ(unclipped_surface_content, child1->drawable_content_rect()); + EXPECT_EQ(unclipped_surface_content, child1->visible_drawable_content_rect()); } TEST_F(DrawPropertiesTest, DrawableAndVisibleContentRectsInHighDPI) { @@ -3048,13 +3069,16 @@ TEST_F(DrawPropertiesTest, DrawableAndVisibleContentRectsInHighDPI) { GetRenderSurface(render_surface1)->DrawableContentRect()); // render_surface2 lives in the "unclipped universe" of render_surface1, and - // is only implicitly clipped by render_surface1. - EXPECT_EQ(gfx::RectF(10.f, 10.f, 350.f, 350.f), + // is only implicitly clipped by render_surface1, though it would only contain + // the visible content. + EXPECT_EQ(gfx::RectF(10.f, 10.f, 180.f, 180.f), GetRenderSurface(render_surface2)->DrawableContentRect()); - EXPECT_EQ(gfx::Rect(10, 10, 100, 100), child1->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(150, 150, 100, 100), child2->drawable_content_rect()); - EXPECT_EQ(gfx::Rect(250, 250, 100, 100), child3->drawable_content_rect()); + EXPECT_EQ(gfx::Rect(10, 10, 100, 100), + child1->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(150, 150, 30, 30), + child2->visible_drawable_content_rect()); + EXPECT_EQ(gfx::Rect(250, 250, 0, 0), child3->visible_drawable_content_rect()); // The root layer does not actually draw content of its own. EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect()); @@ -3400,8 +3424,8 @@ TEST_F(DrawPropertiesTest, RenderSurfaceTransformsInHighDPI) { EXPECT_TRANSFORMATION_MATRIX_EQ( child->ScreenSpaceTransform(), duplicate_child_non_owner->ScreenSpaceTransform()); - EXPECT_EQ(child->drawable_content_rect(), - duplicate_child_non_owner->drawable_content_rect()); + EXPECT_EQ(child->visible_drawable_content_rect(), + duplicate_child_non_owner->visible_drawable_content_rect()); EXPECT_EQ(child->bounds(), duplicate_child_non_owner->bounds()); gfx::Transform expected_render_surface_draw_transform; @@ -3552,6 +3576,74 @@ TEST_F(DrawPropertiesTest, OpacityAnimatingOnPendingTree) { active_child->effect_tree_index())); } +class TransformInteropTest : public DrawPropertiesTestBase, + public testing::Test { + public: + TransformInteropTest() : DrawPropertiesTestBase(TransformInteropSettings()) {} + + protected: + LayerTreeSettings TransformInteropSettings() { + LayerListSettings settings; + + settings.enable_transform_interop = true; + return settings; + } +}; + +TEST_F(TransformInteropTest, BackfaceInvisibleTransform) { + LayerImpl* root = root_layer(); + root->SetDrawsContent(true); + LayerImpl* back_facing = AddLayer<LayerImpl>(); + LayerImpl* back_facing_double_sided = AddLayer<LayerImpl>(); + LayerImpl* front_facing = AddLayer<LayerImpl>(); + back_facing->SetDrawsContent(true); + back_facing_double_sided->SetDrawsContent(true); + front_facing->SetDrawsContent(true); + + root->SetBounds(gfx::Size(50, 50)); + back_facing->SetBounds(gfx::Size(50, 50)); + back_facing_double_sided->SetBounds(gfx::Size(50, 50)); + front_facing->SetBounds(gfx::Size(50, 50)); + CopyProperties(root, back_facing); + CopyProperties(root, front_facing); + + back_facing->SetShouldCheckBackfaceVisibility(true); + back_facing_double_sided->SetShouldCheckBackfaceVisibility(false); + front_facing->SetShouldCheckBackfaceVisibility(true); + + auto& back_facing_transform_node = CreateTransformNode(back_facing); + back_facing_transform_node.flattens_inherited_transform = false; + back_facing_transform_node.sorting_context_id = 1; + gfx::Transform rotate_about_y; + rotate_about_y.RotateAboutYAxis(180.0); + back_facing_transform_node.local = rotate_about_y; + + CopyProperties(back_facing, back_facing_double_sided); + + UpdateActiveTreeDrawProperties(); + + EXPECT_TRUE(draw_property_utils::IsLayerBackFaceVisible( + back_facing, back_facing->transform_tree_index(), + host_impl()->active_tree()->property_trees())); + EXPECT_TRUE(draw_property_utils::IsLayerBackFaceVisible( + back_facing, back_facing_double_sided->transform_tree_index(), + host_impl()->active_tree()->property_trees())); + EXPECT_FALSE(draw_property_utils::IsLayerBackFaceVisible( + front_facing, front_facing->transform_tree_index(), + host_impl()->active_tree()->property_trees())); + + EXPECT_TRUE( + draw_property_utils::LayerShouldBeSkippedForDrawPropertiesComputation( + back_facing, host_impl()->active_tree()->property_trees())); + EXPECT_FALSE( + draw_property_utils::LayerShouldBeSkippedForDrawPropertiesComputation( + back_facing_double_sided, + host_impl()->active_tree()->property_trees())); + EXPECT_FALSE( + draw_property_utils::LayerShouldBeSkippedForDrawPropertiesComputation( + front_facing, host_impl()->active_tree()->property_trees())); +} + using LCDTextTestParam = std::tuple<bool, bool>; class LCDTextTest : public DrawPropertiesTestBase, public testing::TestWithParam<LCDTextTestParam> { @@ -3699,6 +3791,16 @@ TEST_P(LCDTextTest, CanUseLCDText) { CheckCanUseLCDText(LCDTextDisallowedReason::kNone, grand_child_); } +TEST_P(LCDTextTest, CanUseLCDTextWithContentsOpaqueForText) { + child_->SetContentsOpaque(false); + child_->SetBackgroundColor(SK_ColorGREEN); + child_->SetContentsOpaqueForText(true); + CheckCanUseLCDText(LCDTextDisallowedReason::kNone, child_); + + child_->SetContentsOpaqueForText(false); + CheckCanUseLCDText(LCDTextDisallowedReason::kContentsNotOpaque, child_); +} + TEST_P(LCDTextTest, CanUseLCDTextWithAnimation) { // Sanity check: Make sure can_use_lcd_text_ is set on each node. UpdateActiveTreeDrawProperties(); @@ -4232,19 +4334,19 @@ TEST_F(DrawPropertiesTest, ClipParentWithInterveningRenderSurface) { EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface2->clip_rect()); EXPECT_TRUE(render_surface2->is_clipped()); - // The content rects of render_surface2 should have expanded to contain the - // clip child. - EXPECT_EQ(gfx::Rect(0, 0, 40, 40), - GetRenderSurface(render_surface1)->content_rect()); - EXPECT_EQ(gfx::Rect(-10, -10, 60, 60), - GetRenderSurface(render_surface2)->content_rect()); - // The clip child should have inherited the clip parent's clip (projected to // the right space, of course), but as render_surface1 already applies that // clip, clip_child need not apply it again. EXPECT_EQ(gfx::Rect(), clip_child->clip_rect()); EXPECT_EQ(gfx::Rect(9, 9, 40, 40), clip_child->visible_layer_rect()); EXPECT_FALSE(clip_child->is_clipped()); + + // The content rects of render_surface2 should have expanded to contain the + // clip child, but only the visible part of the clip child. + EXPECT_EQ(gfx::Rect(0, 0, 40, 40), + GetRenderSurface(render_surface1)->content_rect()); + EXPECT_EQ(clip_child->visible_drawable_content_rect(), + GetRenderSurface(render_surface2)->content_rect()); } TEST_F(DrawPropertiesTest, ClipParentScrolledInterveningLayer) { @@ -4329,19 +4431,19 @@ TEST_F(DrawPropertiesTest, ClipParentScrolledInterveningLayer) { EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface2->clip_rect()); EXPECT_TRUE(render_surface2->is_clipped()); - // The content rects of render_surface2 should have expanded to contain the - // clip child. - EXPECT_EQ(gfx::Rect(0, 0, 40, 40), - GetRenderSurface(render_surface1)->content_rect()); - EXPECT_EQ(gfx::Rect(-10, -10, 60, 60), - GetRenderSurface(render_surface2)->content_rect()); - // The clip child should have inherited the clip parent's clip (projected to // the right space, of course), but as render_surface1 already applies that // clip, clip_child need not apply it again. EXPECT_EQ(gfx::Rect(), clip_child->clip_rect()); EXPECT_EQ(gfx::Rect(12, 12, 40, 40), clip_child->visible_layer_rect()); EXPECT_FALSE(clip_child->is_clipped()); + + // The content rects of render_surface2 should have expanded to contain the + // clip child, but only the visible part of the clip child. + EXPECT_EQ(gfx::Rect(0, 0, 40, 40), + GetRenderSurface(render_surface1)->content_rect()); + EXPECT_EQ(clip_child->visible_drawable_content_rect(), + GetRenderSurface(render_surface2)->content_rect()); } TEST_F(DrawPropertiesTest, DescendantsOfClipChildren) { @@ -6904,7 +7006,8 @@ TEST_F(DrawPropertiesTest, RenderSurfaceWithUnclippedDescendantsClipsSubtree) { EXPECT_TRUE(test_layer->is_clipped()); EXPECT_FALSE(test_layer->render_target()->is_clipped()); EXPECT_EQ(gfx::Rect(-2, -2, 30, 30), test_layer->clip_rect()); - EXPECT_EQ(gfx::Rect(28, 28), test_layer->drawable_content_rect()); + EXPECT_EQ(gfx::Rect(26, 26), test_layer->visible_layer_rect()); + EXPECT_EQ(gfx::Rect(26, 26), test_layer->visible_drawable_content_rect()); } TEST_F(DrawPropertiesTest, @@ -7059,7 +7162,7 @@ TEST_F(DrawPropertiesTest, RenderSurfaceContentRectWithMultipleSurfaces) { GetRenderSurface(unclipped_surface)->content_rect()); EXPECT_EQ(gfx::Rect(50, 50), GetRenderSurface(unclipped_desc_surface)->content_rect()); - EXPECT_EQ(gfx::Rect(60, 60), + EXPECT_EQ(gfx::Rect(50, 50), GetRenderSurface(unclipped_desc_surface2)->content_rect()); EXPECT_EQ(gfx::Rect(50, 50), GetRenderSurface(clipped_surface)->content_rect()); @@ -7724,7 +7827,8 @@ TEST_F(DrawPropertiesTestWithLayerTree, CopyRequestScalingTest) { EXPECT_EQ(gfx::Rect(10, 10), ImplOf(test_layer)->visible_layer_rect()); EXPECT_EQ(transform, ImplOf(test_layer)->DrawTransform()); EXPECT_EQ(gfx::Rect(50, 50), ImplOf(test_layer)->clip_rect()); - EXPECT_EQ(gfx::Rect(50, 50), ImplOf(test_layer)->drawable_content_rect()); + EXPECT_EQ(gfx::Rect(50, 50), + ImplOf(test_layer)->visible_drawable_content_rect()); // Clear the copy request and call UpdateSurfaceContentsScale. GetPropertyTrees(root.get())->effect_tree.ClearCopyRequests(); diff --git a/chromium/cc/trees/draw_property_utils.cc b/chromium/cc/trees/draw_property_utils.cc index f9fdebf8218..7c65e513700 100644 --- a/chromium/cc/trees/draw_property_utils.cc +++ b/chromium/cc/trees/draw_property_utils.cc @@ -11,6 +11,7 @@ #include "base/containers/adapters.h" #include "base/containers/stack.h" +#include "base/logging.h" #include "cc/base/math_util.h" #include "cc/layers/draw_properties.h" #include "cc/layers/layer.h" @@ -381,6 +382,12 @@ bool IsTargetSpaceTransformBackFaceVisible( LayerImpl* layer, int transform_tree_index, const PropertyTrees* property_trees) { + const TransformTree& transform_tree = property_trees->transform_tree; + const TransformNode& transform_node = + *transform_tree.Node(transform_tree_index); + if (transform_node.delegates_to_parent_for_backface) + transform_tree_index = transform_node.parent_id; + gfx::Transform to_target; property_trees->GetToTarget(transform_tree_index, layer->render_target_effect_tree_index(), @@ -388,12 +395,42 @@ bool IsTargetSpaceTransformBackFaceVisible( return to_target.IsBackFaceVisible(); } -template <typename LayerType> -bool IsLayerBackFaceVisible(LayerType* layer, - int transform_tree_index, - const PropertyTrees* property_trees) { - return IsTargetSpaceTransformBackFaceVisible(layer, transform_tree_index, - property_trees); +bool IsTransformToRootOf3DRenderingContextBackFaceVisible( + Layer* layer, + int transform_tree_index, + const PropertyTrees* property_trees) { + // We do not skip back face invisible layers on main thread as target space + // transform will not be available here. + return false; +} + +bool IsTransformToRootOf3DRenderingContextBackFaceVisible( + LayerImpl* layer, + int transform_tree_index, + const PropertyTrees* property_trees) { + const TransformTree& transform_tree = property_trees->transform_tree; + + const TransformNode& transform_node = + *transform_tree.Node(transform_tree_index); + if (transform_node.delegates_to_parent_for_backface) + transform_tree_index = transform_node.parent_id; + + int root_id = transform_tree_index; + int sorting_context_id = transform_node.sorting_context_id; + + while (root_id > 0 && transform_tree.Node(root_id - 1)->sorting_context_id == + sorting_context_id) + root_id--; + + // TODO(chrishtr): cache this on the transform trees if needed, similar to + // |to_target| and |to_screen|. + gfx::Transform to_3d_root; + if (transform_tree_index != root_id) + property_trees->transform_tree.CombineTransformsBetween( + transform_tree_index, root_id, &to_3d_root); + to_3d_root.PreconcatTransform( + property_trees->transform_tree.Node(root_id)->to_parent); + return to_3d_root.IsBackFaceVisible(); } inline bool TransformToScreenIsKnown(Layer* layer, @@ -445,7 +482,8 @@ bool LayerNeedsUpdate(LayerType* layer, // backface is not visible. if (TransformToScreenIsKnown(layer, backface_transform_id, tree) && !HasSingularTransform(backface_transform_id, tree) && - IsLayerBackFaceVisible(layer, backface_transform_id, property_trees)) { + draw_property_utils::IsLayerBackFaceVisible( + layer, backface_transform_id, property_trees)) { UMA_HISTOGRAM_BOOLEAN( "Compositing.Renderer.LayerUpdateSkippedDueToBackface", true); return false; @@ -474,35 +512,6 @@ inline bool LayerShouldBeSkippedForDrawPropertiesComputation( !effect_node->is_drawn; } -inline bool LayerShouldBeSkippedForDrawPropertiesComputation( - LayerImpl* layer, - const TransformTree& transform_tree, - const EffectTree& effect_tree) { - const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index()); - - if (effect_node->HasRenderSurface() && effect_node->subtree_has_copy_request) - return false; - - // Skip if the node's subtree is hidden and no need to cache. - if (effect_node->subtree_hidden && !effect_node->cache_render_surface) - return true; - - // If the layer transform is not invertible, it should be skipped. In case the - // transform is animating and singular, we should not skip it. - const TransformNode* transform_node = - transform_tree.Node(layer->transform_tree_index()); - - if (!transform_node->node_and_ancestors_are_animated_or_invertible || - !effect_node->is_drawn) - return true; - - UMA_HISTOGRAM_BOOLEAN( - "Compositing.Renderer.LayerSkippedForDrawPropertiesDueToBackface", - effect_node->hidden_by_backface_visibility); - - return effect_node->hidden_by_backface_visibility; -} - gfx::Rect LayerDrawableContentRect( const LayerImpl* layer, const gfx::Rect& layer_bounds_in_target_space, @@ -922,8 +931,8 @@ void ComputeInitialRenderSurfaceList(LayerTreeImpl* layer_tree_impl, bool is_root = layer_tree_impl->IsRootLayer(layer); bool skip_draw_properties_computation = - LayerShouldBeSkippedForDrawPropertiesComputation( - layer, property_trees->transform_tree, property_trees->effect_tree); + draw_property_utils::LayerShouldBeSkippedForDrawPropertiesComputation( + layer, property_trees); bool skip_for_invertibility = SkipForInvertibility(layer, property_trees); @@ -1138,11 +1147,19 @@ void ComputeDrawPropertiesOfVisibleLayers(const LayerImplList* layer_list, // Compute drawable content rects for (LayerImpl* layer : *layer_list) { - gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect( - layer->draw_properties().target_space_transform, - gfx::Rect(layer->bounds())); - layer->draw_properties().drawable_content_rect = LayerDrawableContentRect( - layer, bounds_in_target_space, layer->draw_properties().clip_rect); + bool only_draws_visible_content = + property_trees->effect_tree.Node(layer->effect_tree_index()) + ->only_draws_visible_content; + gfx::Rect drawable_bounds = gfx::Rect(layer->visible_layer_rect()); + if (!only_draws_visible_content) { + drawable_bounds = gfx::Rect(layer->bounds()); + } + gfx::Rect visible_bounds_in_target_space = + MathUtil::MapEnclosingClippedRect( + layer->draw_properties().target_space_transform, drawable_bounds); + layer->draw_properties().visible_drawable_content_rect = + LayerDrawableContentRect(layer, visible_bounds_in_target_space, + layer->draw_properties().clip_rect); } } @@ -1164,6 +1181,61 @@ bool NodeMayContainBackdropBlurFilter(const EffectNode& node) { } // namespace +bool CC_EXPORT LayerShouldBeSkippedForDrawPropertiesComputation( + LayerImpl* layer, + const PropertyTrees* property_trees) { + const TransformTree& transform_tree = property_trees->transform_tree; + const EffectTree& effect_tree = property_trees->effect_tree; + const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index()); + + if (effect_node->HasRenderSurface() && effect_node->subtree_has_copy_request) + return false; + + // Skip if the node's subtree is hidden and no need to cache. + if (effect_node->subtree_hidden && !effect_node->cache_render_surface) + return true; + + // If the layer transform is not invertible, it should be skipped. In case the + // transform is animating and singular, we should not skip it. + const TransformNode* transform_node = + transform_tree.Node(layer->transform_tree_index()); + + if (!transform_node->node_and_ancestors_are_animated_or_invertible || + !effect_node->is_drawn) + return true; + if (layer->layer_tree_impl()->settings().enable_transform_interop) { + return layer->should_check_backface_visibility() && + IsLayerBackFaceVisible(layer, layer->transform_tree_index(), + property_trees); + } else { + return effect_node->hidden_by_backface_visibility; + } +} + +bool CC_EXPORT IsLayerBackFaceVisible(LayerImpl* layer, + int transform_tree_index, + const PropertyTrees* property_trees) { + if (layer->layer_tree_impl()->settings().enable_transform_interop) { + return IsTransformToRootOf3DRenderingContextBackFaceVisible( + layer, transform_tree_index, property_trees); + } else { + return IsTargetSpaceTransformBackFaceVisible(layer, transform_tree_index, + property_trees); + } +} + +bool CC_EXPORT IsLayerBackFaceVisible(Layer* layer, + int transform_tree_index, + const PropertyTrees* property_trees) { + if (layer->layer_tree_host()->GetSettings().enable_transform_interop) { + return IsTransformToRootOf3DRenderingContextBackFaceVisible( + layer, transform_tree_index, property_trees); + } else { + return IsTargetSpaceTransformBackFaceVisible(layer, transform_tree_index, + property_trees); + } +} + void ConcatInverseSurfaceContentsScale(const EffectNode* effect_node, gfx::Transform* transform) { DCHECK(effect_node->HasRenderSurface()); @@ -1195,7 +1267,6 @@ void FindLayersThatNeedUpdates(LayerTreeHost* layer_tree_host, void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl, std::vector<LayerImpl*>* visible_layer_list) { const PropertyTrees* property_trees = layer_tree_impl->property_trees(); - const TransformTree& transform_tree = property_trees->transform_tree; const EffectTree& effect_tree = property_trees->effect_tree; for (auto* layer_impl : *layer_tree_impl) { @@ -1204,8 +1275,8 @@ void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl, layer_impl->EnsureValidPropertyTreeIndices(); if (!IsRootLayer(layer_impl) && - LayerShouldBeSkippedForDrawPropertiesComputation( - layer_impl, transform_tree, effect_tree)) + LayerShouldBeSkippedForDrawPropertiesComputation(layer_impl, + property_trees)) continue; bool layer_is_drawn = diff --git a/chromium/cc/trees/draw_property_utils.h b/chromium/cc/trees/draw_property_utils.h index c42684eefce..b80b38e3ab9 100644 --- a/chromium/cc/trees/draw_property_utils.h +++ b/chromium/cc/trees/draw_property_utils.h @@ -68,6 +68,18 @@ void CC_EXPORT CalculateDrawProperties( RenderSurfaceList* output_render_surface_list, LayerImplList* output_update_layer_list_for_testing = nullptr); +bool CC_EXPORT LayerShouldBeSkippedForDrawPropertiesComputation( + LayerImpl* layer, + const PropertyTrees* property_trees); + +bool CC_EXPORT IsLayerBackFaceVisible(LayerImpl* layer, + int transform_tree_index, + const PropertyTrees* property_trees); + +bool CC_EXPORT IsLayerBackFaceVisible(Layer* layer, + int transform_tree_index, + const PropertyTrees* property_trees); + #if DCHECK_IS_ON() // Checks and logs if double background blur exists in any layers. Returns // true if no double background blur is detected, false otherwise. diff --git a/chromium/cc/trees/effect_node.cc b/chromium/cc/trees/effect_node.cc index a412c237f1c..9bae1e90b74 100644 --- a/chromium/cc/trees/effect_node.cc +++ b/chromium/cc/trees/effect_node.cc @@ -23,6 +23,7 @@ EffectNode::EffectNode() double_sided(true), trilinear_filtering(false), is_drawn(true), + only_draws_visible_content(true), subtree_hidden(false), has_potential_filter_animation(false), has_potential_backdrop_filter_animation(false), @@ -56,7 +57,6 @@ bool EffectNode::operator==(const EffectNode& other) const { backdrop_filters == other.backdrop_filters && backdrop_filter_bounds == other.backdrop_filter_bounds && backdrop_mask_element_id == other.backdrop_mask_element_id && - filters_origin == other.filters_origin && rounded_corner_bounds == other.rounded_corner_bounds && is_fast_rounded_corner == other.is_fast_rounded_corner && // The specific reason is just for tracing/testing/debugging, so just @@ -67,7 +67,9 @@ bool EffectNode::operator==(const EffectNode& other) const { hidden_by_backface_visibility == other.hidden_by_backface_visibility && double_sided == other.double_sided && trilinear_filtering == other.trilinear_filtering && - is_drawn == other.is_drawn && subtree_hidden == other.subtree_hidden && + is_drawn == other.is_drawn && + only_draws_visible_content == other.only_draws_visible_content && + subtree_hidden == other.subtree_hidden && has_potential_filter_animation == other.has_potential_filter_animation && has_potential_backdrop_filter_animation == @@ -163,6 +165,7 @@ void EffectNode::AsValueInto(base::trace_event::TracedValue* value) const { hidden_by_backface_visibility); value->SetBoolean("trilinear_filtering", trilinear_filtering); value->SetBoolean("is_drawn", is_drawn); + value->SetBoolean("only_draws_visible_content", only_draws_visible_content); value->SetBoolean("has_potential_filter_animation", has_potential_filter_animation); value->SetBoolean("has_potential_backdrop_filter_animation", diff --git a/chromium/cc/trees/effect_node.h b/chromium/cc/trees/effect_node.h index 01f662563e1..6663457250c 100644 --- a/chromium/cc/trees/effect_node.h +++ b/chromium/cc/trees/effect_node.h @@ -96,6 +96,13 @@ struct CC_EXPORT EffectNode { bool double_sided : 1; bool trilinear_filtering : 1; bool is_drawn : 1; + // In most cases we only need to draw the visible part of any content + // contributing to the effect. For copy request case, we would need to copy + // the entire content, and could not only draw the visible part. In the rare + // case of a backdrop zoom filter we need to take into consideration the + // content offscreen to make sure the backdrop zoom filter is applied with the + // correct center. + bool only_draws_visible_content : 1; // TODO(jaydasika) : Delete this after implementation of // SetHideLayerAndSubtree is cleaned up. (crbug.com/595843) bool subtree_hidden : 1; diff --git a/chromium/cc/trees/frame_rate_counter.cc b/chromium/cc/trees/frame_rate_counter.cc deleted file mode 100644 index 816877c4ab3..00000000000 --- a/chromium/cc/trees/frame_rate_counter.cc +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2012 The Chromium 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 "cc/trees/frame_rate_counter.h" - -#include <stddef.h> - -#include <algorithm> -#include <limits> - -#include "base/memory/ptr_util.h" -#include "base/metrics/histogram_macros.h" - -namespace cc { - -// The following constants are measured in seconds. - -// Two thresholds (measured in seconds) that describe what is considered to be a -// "no-op frame" that should not be counted. -// - if the frame is too fast, then given our compositor implementation, the -// frame probably was a no-op and did not draw. -// - if the frame is too slow, then there is probably not animating content, so -// we should not pollute the average. -static const double kFrameTooFast = 1.0 / 70.0; -static const double kFrameTooSlow = 1.5; - -// If a frame takes longer than this threshold (measured in seconds) then we -// (naively) assume that it missed a screen refresh; that is, we dropped a -// frame. -// TODO(brianderson): Determine this threshold based on monitor refresh rate, -// crbug.com/138642. -static const double kDroppedFrameTime = 1.0 / 50.0; - -// static -std::unique_ptr<FrameRateCounter> FrameRateCounter::Create( - bool has_impl_thread) { - return base::WrapUnique(new FrameRateCounter(has_impl_thread)); -} - -base::TimeDelta FrameRateCounter::RecentFrameInterval(size_t n) const { - DCHECK_GT(n, 0u); - DCHECK_LT(n, ring_buffer_.BufferSize()); - return ring_buffer_.ReadBuffer(n) - ring_buffer_.ReadBuffer(n - 1); -} - -FrameRateCounter::FrameRateCounter(bool has_impl_thread) - : has_impl_thread_(has_impl_thread), dropped_frame_count_(0) {} - -void FrameRateCounter::SaveTimeStamp(base::TimeTicks timestamp) { - ring_buffer_.SaveToBuffer(timestamp); - - // Check if frame interval can be computed. - if (ring_buffer_.CurrentIndex() < 2) - return; - - base::TimeDelta frame_interval_seconds = - RecentFrameInterval(ring_buffer_.BufferSize() - 1); - - if (!IsBadFrameInterval(frame_interval_seconds) && - frame_interval_seconds.InSecondsF() > kDroppedFrameTime) - dropped_frame_count_ += - frame_interval_seconds.InSecondsF() / kDroppedFrameTime; -} - -bool FrameRateCounter::IsBadFrameInterval( - base::TimeDelta interval_between_consecutive_frames) const { - double delta = interval_between_consecutive_frames.InSecondsF(); - bool scheduler_allows_double_frames = !has_impl_thread_; - bool interval_too_fast = - scheduler_allows_double_frames ? delta < kFrameTooFast : delta <= 0.0; - bool interval_too_slow = delta > kFrameTooSlow; - return interval_too_fast || interval_too_slow; -} - -void FrameRateCounter::GetMinAndMaxFPS(double* min_fps, double* max_fps) const { - *min_fps = std::numeric_limits<double>::max(); - *max_fps = 0.0; - - for (RingBufferType::Iterator it = --ring_buffer_.End(); it; --it) { - base::TimeDelta delta = RecentFrameInterval(it.index() + 1); - - if (IsBadFrameInterval(delta)) - continue; - - DCHECK_GT(delta.InSecondsF(), 0.f); - double fps = 1.0 / delta.InSecondsF(); - - *min_fps = std::min(fps, *min_fps); - *max_fps = std::max(fps, *max_fps); - } - - if (*min_fps > *max_fps) - *min_fps = *max_fps; -} - -double FrameRateCounter::GetAverageFPS() const { - int frame_count = 0; - double frame_times_total = 0.0; - double average_fps = 0.0; - - // Walk backwards through the samples looking for a run of good frame - // timings from which to compute the mean. - // - // Slow frames occur just because the user is inactive, and should be - // ignored. Fast frames are ignored if the scheduler is in single-thread - // mode in order to represent the true frame rate in spite of the fact that - // the first few swapbuffers happen instantly which skews the statistics - // too much for short lived animations. - // - // IsBadFrameInterval encapsulates the frame too slow/frame too fast logic. - - for (RingBufferType::Iterator it = --ring_buffer_.End(); - it && frame_times_total < 1.0; --it) { - base::TimeDelta delta = RecentFrameInterval(it.index() + 1); - - if (!IsBadFrameInterval(delta)) { - frame_count++; - frame_times_total += delta.InSecondsF(); - } else if (frame_count) { - break; - } - } - - if (frame_count) { - DCHECK_GT(frame_times_total, 0.0); - average_fps = frame_count / frame_times_total; - } - - return average_fps; -} - -} // namespace cc diff --git a/chromium/cc/trees/frame_rate_counter.h b/chromium/cc/trees/frame_rate_counter.h deleted file mode 100644 index f1445fb16da..00000000000 --- a/chromium/cc/trees/frame_rate_counter.h +++ /dev/null @@ -1,60 +0,0 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef CC_TREES_FRAME_RATE_COUNTER_H_ -#define CC_TREES_FRAME_RATE_COUNTER_H_ - -#include <stddef.h> - -#include <memory> - -#include "base/containers/ring_buffer.h" -#include "base/time/time.h" - -namespace cc { - -// This class maintains a history of timestamps, and provides functionality to -// intelligently compute average frames per second. -class FrameRateCounter { - public: - static std::unique_ptr<FrameRateCounter> Create(bool has_impl_thread); - - FrameRateCounter(const FrameRateCounter&) = delete; - FrameRateCounter& operator=(const FrameRateCounter&) = delete; - - size_t current_frame_number() const { return ring_buffer_.CurrentIndex(); } - int dropped_frame_count() const { return dropped_frame_count_; } - size_t time_stamp_history_size() const { return ring_buffer_.BufferSize(); } - - void SaveTimeStamp(base::TimeTicks timestamp); - - // n = 0 returns the oldest frame interval retained in the history, while n = - // time_stamp_history_size() - 1 returns the most recent frame interval. - base::TimeDelta RecentFrameInterval(size_t n) const; - - // This is a heuristic that can be used to ignore frames in a reasonable way. - // Returns true if the given frame interval is too fast or too slow, based on - // constant thresholds. - bool IsBadFrameInterval( - base::TimeDelta interval_between_consecutive_frames) const; - - void GetMinAndMaxFPS(double* min_fps, double* max_fps) const; - double GetAverageFPS() const; - - typedef base::RingBuffer<base::TimeTicks, 136> RingBufferType; - RingBufferType::Iterator begin() const { return ring_buffer_.Begin(); } - RingBufferType::Iterator end() const { return ring_buffer_.End(); } - - private: - explicit FrameRateCounter(bool has_impl_thread); - - RingBufferType ring_buffer_; - - bool has_impl_thread_; - int dropped_frame_count_; -}; - -} // namespace cc - -#endif // CC_TREES_FRAME_RATE_COUNTER_H_ diff --git a/chromium/cc/trees/image_animation_controller.cc b/chromium/cc/trees/image_animation_controller.cc index a7e1ebf6de6..2cb4f9d1bd1 100644 --- a/chromium/cc/trees/image_animation_controller.cc +++ b/chromium/cc/trees/image_animation_controller.cc @@ -4,6 +4,8 @@ #include "cc/trees/image_animation_controller.h" +#include <sstream> + #include "base/bind.h" #include "base/metrics/histogram_macros.h" #include "base/trace_event/trace_event.h" @@ -360,6 +362,25 @@ bool ImageAnimationController::AnimationState::AdvanceFrame( // skipped trying to catch up. DCHECK_GT(num_of_frames_advanced, 0u); last_num_frames_skipped_ = num_of_frames_advanced - 1u; + switch (repetitions_completed_) { + case 0: + UMA_HISTOGRAM_COUNTS_100000( + "AnimatedImage.NumOfFramesSkipped.FirstAnimationLoop", + last_num_frames_skipped_); + break; + case 1: + UMA_HISTOGRAM_COUNTS_100000( + "AnimatedImage.NumOfFramesSkipped.SecondAnimationLoop", + last_num_frames_skipped_); + break; + case 2: + case 3: + case 4: + UMA_HISTOGRAM_COUNTS_100000( + "AnimatedImage.NumOfFramesSkipped.ThirdToFifthAnimationLoop", + last_num_frames_skipped_); + break; + } UMA_HISTOGRAM_COUNTS_100000("AnimatedImage.NumOfFramesSkipped.Compositor", last_num_frames_skipped_); return needs_invalidation(); diff --git a/chromium/cc/trees/layer_tree_host.cc b/chromium/cc/trees/layer_tree_host.cc index b1a4798682b..d5e57eaa4a5 100644 --- a/chromium/cc/trees/layer_tree_host.cc +++ b/chromium/cc/trees/layer_tree_host.cc @@ -18,6 +18,7 @@ #include "base/command_line.h" #include "base/containers/adapters.h" #include "base/location.h" +#include "base/logging.h" #include "base/memory/ptr_util.h" #include "base/metrics/histogram_functions.h" #include "base/metrics/histogram_macros.h" @@ -94,6 +95,9 @@ LayerTreeHost::InitParams::InitParams(InitParams&&) = default; LayerTreeHost::InitParams& LayerTreeHost::InitParams::operator=(InitParams&&) = default; +LayerTreeHost::ScrollAnimationState::ScrollAnimationState() = default; +LayerTreeHost::ScrollAnimationState::~ScrollAnimationState() = default; + std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded( scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner, InitParams params) { @@ -263,14 +267,6 @@ const LayerTreeSettings& LayerTreeHost::GetSettings() const { void LayerTreeHost::QueueSwapPromise( std::unique_ptr<SwapPromise> swap_promise) { swap_promise_manager_.QueueSwapPromise(std::move(swap_promise)); - - // Request a main frame if one is not already in progress. This might either - // A) request a commit ahead of time or B) request a commit which is not - // needed because there are not pending updates. If B) then the frame will - // be aborted early and the swap promises will be broken (see - // EarlyOut_NoUpdates). - if (!inside_main_frame_) - SetNeedsAnimate(); } void LayerTreeHost::WillBeginMainFrame() { @@ -609,6 +605,11 @@ void LayerTreeHost::SetNeedsAnimate() { events_metrics_manager_.SaveActiveEventMetrics(); } +void LayerTreeHost::SetNeedsAnimateIfNotInsideMainFrame() { + if (!inside_main_frame_) + SetNeedsAnimate(); +} + DISABLE_CFI_PERF void LayerTreeHost::SetNeedsUpdateLayers() { proxy_->SetNeedsUpdateLayers(); @@ -785,6 +786,13 @@ bool LayerTreeHost::CaptureContent(std::vector<NodeId>* content) { return true; } +void LayerTreeHost::DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) { + client_->DidObserveFirstScrollDelay(first_scroll_delay, + first_scroll_timestamp); +} + bool LayerTreeHost::DoUpdateLayers() { TRACE_EVENT1("cc,benchmark", "LayerTreeHost::DoUpdateLayers", "source_frame_number", SourceFrameNumber()); @@ -849,6 +857,24 @@ void LayerTreeHost::ApplyViewportChanges(const ScrollAndScaleSet& info) { if (info.inner_viewport_scroll.element_id) inner_viewport_scroll_delta = info.inner_viewport_scroll.scroll_delta; + // When a new scroll-animation starts, it is necessary to check + // |info.manipulation_info| to make sure the scroll-animation was started by + // an input event. + // If there is already an ongoing scroll-animation, then it is necessary to + // only look at |info.ongoing_scroll_animation| (since it is possible for the + // scroll-animation to continue even if no event was handled). + bool new_ongoing_scroll = + scroll_animation_.in_progress + ? info.ongoing_scroll_animation + : (info.ongoing_scroll_animation && info.manipulation_info); + if (scroll_animation_.in_progress && !new_ongoing_scroll) { + scroll_animation_.in_progress = false; + if (!scroll_animation_.end_notification.is_null()) + std::move(scroll_animation_.end_notification).Run(); + } else { + scroll_animation_.in_progress = new_ongoing_scroll; + } + if (inner_viewport_scroll_delta.IsZero() && info.page_scale_delta == 1.f && info.elastic_overscroll_delta.IsZero() && !info.top_controls_delta && !info.bottom_controls_delta && @@ -985,6 +1011,14 @@ void LayerTreeHost::NotifyThroughputTrackerResults( client_->NotifyThroughputTrackerResults(std::move(results)); } +void LayerTreeHost::SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) { + client_->SubmitThroughputData(source_id, aggregated_percent, impl_percent, + main_percent); +} + const base::WeakPtr<InputHandler>& LayerTreeHost::GetInputHandler() const { return input_handler_weak_ptr_; } @@ -1068,6 +1102,15 @@ void LayerTreeHost::RequestPresentationTimeForNextFrame( pending_presentation_time_callbacks_.push_back(std::move(callback)); } +void LayerTreeHost::RequestScrollAnimationEndNotification( + base::OnceClosure callback) { + DCHECK(scroll_animation_.end_notification.is_null()); + if (scroll_animation_.in_progress) + scroll_animation_.end_notification = std::move(callback); + else + std::move(callback).Run(); +} + void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) { if (root_layer_.get() == root_layer.get()) return; @@ -1118,9 +1161,13 @@ Layer* LayerTreeHost::InnerViewportScrollLayerForTesting() const { } Layer* LayerTreeHost::OuterViewportScrollLayerForTesting() const { + return LayerByElementId(OuterViewportScrollElementId()); +} + +ElementId LayerTreeHost::OuterViewportScrollElementId() const { auto* scroll_node = property_trees()->scroll_tree.Node(viewport_property_ids_.outer_scroll); - return scroll_node ? LayerByElementId(scroll_node->element_id) : nullptr; + return scroll_node ? scroll_node->element_id : ElementId(); } void LayerTreeHost::RegisterSelection(const LayerSelection& selection) { @@ -1439,10 +1486,6 @@ void LayerTreeHost::AddLayerShouldPushProperties(Layer* layer) { layers_that_should_push_properties_.insert(layer); } -void LayerTreeHost::RemoveLayerShouldPushProperties(Layer* layer) { - layers_that_should_push_properties_.erase(layer); -} - void LayerTreeHost::ClearLayersThatShouldPushProperties() { layers_that_should_push_properties_.clear(); } @@ -1566,6 +1609,9 @@ void LayerTreeHost::PushLayerTreePropertiesTo(LayerTreeImpl* tree_impl) { } tree_impl->set_display_transform_hint(display_transform_hint_); + + if (delegated_ink_metadata_) + tree_impl->set_delegated_ink_metadata(std::move(delegated_ink_metadata_)); } void LayerTreeHost::PushSurfaceRangesTo(LayerTreeImpl* tree_impl) { diff --git a/chromium/cc/trees/layer_tree_host.h b/chromium/cc/trees/layer_tree_host.h index 8aae435b230..f365bd9a909 100644 --- a/chromium/cc/trees/layer_tree_host.h +++ b/chromium/cc/trees/layer_tree_host.h @@ -13,6 +13,7 @@ #include <set> #include <string> #include <unordered_map> +#include <utility> #include <vector> #include "base/callback_forward.h" @@ -49,6 +50,7 @@ #include "cc/trees/swap_promise_manager.h" #include "cc/trees/target_property.h" #include "cc/trees/viewport_layers.h" +#include "components/viz/common/delegated_ink_metadata.h" #include "components/viz/common/resources/resource_format.h" #include "components/viz/common/surfaces/local_surface_id_allocation.h" #include "services/metrics/public/cpp/ukm_source_id.h" @@ -215,6 +217,9 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { // full commit synchronization or layer updates. void SetNeedsAnimate(); + // Calls SetNeedsAnimate() if there is no main frame already in progress. + void SetNeedsAnimateIfNotInsideMainFrame(); + // Requests a main frame update and also ensure that the host pulls layer // updates from the client, even if no content might have changed, without // forcing a full commit synchronization. @@ -316,6 +321,10 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { base::OnceCallback<void(const gfx::PresentationFeedback&)>; void RequestPresentationTimeForNextFrame(PresentationTimeCallback callback); + // Registers a callback that is run when any ongoing scroll-animation ends. If + // there are no ongoing animations, then the callback is run immediately. + void RequestScrollAnimationEndNotification(base::OnceClosure callback); + // Layer tree accessors and modifiers ------------------------ // Sets or gets the root of the Layer tree. Children of the root Layer are @@ -352,6 +361,8 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { Layer* InnerViewportScrollLayerForTesting() const; Layer* OuterViewportScrollLayerForTesting() const; + ElementId OuterViewportScrollElementId() const; + // Sets or gets the position of touch handles for a text selection. These are // submitted to the display compositor along with the Layer tree's contents // allowing it to present the selection handles. This is done because the @@ -388,8 +399,6 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { void SetViewportVisibleRect(const gfx::Rect& visible_rect); - gfx::Rect viewport_visible_rect() const { return viewport_visible_rect_; } - gfx::Rect device_viewport_rect() const { return device_viewport_rect_; } void SetBrowserControlsParams(const BrowserControlsParams& params); @@ -457,6 +466,10 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { return raster_color_space_; } + bool HasCompositorDrivenScrollAnimationForTesting() const { + return scroll_animation_.in_progress; + } + // This layer tree may be embedded in a hierarchy that has page scale // factor controlled at the top level. We represent that scale here as // 'external_page_scale_factor', a value that affects raster scale in the @@ -503,7 +516,6 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { // These are internal methods, called from the Layer itself when changing a // property or completing a PushPropertiesTo. void AddLayerShouldPushProperties(Layer* layer); - void RemoveLayerShouldPushProperties(Layer* layer); void ClearLayersThatShouldPushProperties(); // The current set of all Layers attached to the LayerTreeHost's tree that // have been marked as needing PushPropertiesTo in the next commit. @@ -593,6 +605,10 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { void RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time, ActiveFrameSequenceTrackers trackers); void NotifyThroughputTrackerResults(CustomTrackerResults results); + void SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent); LayerTreeHostClient* client() { return client_; } LayerTreeHostSchedulingClient* scheduling_client() { @@ -693,6 +709,17 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { impl_commit_start_time_ = commit_start_time; } + void SetDelegatedInkMetadata( + std::unique_ptr<viz::DelegatedInkMetadata> metadata) { + delegated_ink_metadata_ = std::move(metadata); + } + viz::DelegatedInkMetadata* DelegatedInkMetadataForTesting() { + return delegated_ink_metadata_.get(); + } + + void DidObserveFirstScrollDelay(base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp); + protected: LayerTreeHost(InitParams params, CompositorMode mode); @@ -886,6 +913,17 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { // added here. std::vector<PresentationTimeCallback> pending_presentation_time_callbacks_; + struct ScrollAnimationState { + ScrollAnimationState(); + ~ScrollAnimationState(); + + // Tracks whether there is an ongoing compositor-driven scroll animation. + bool in_progress = false; + + // Callback to run when the scroll-animation ends. + base::OnceClosure end_notification; + } scroll_animation_; + // Latency information for work done in ProxyMain::BeginMainFrame. The // unique_ptr is allocated in RequestMainFrameUpdate, and passed to Blink's // LocalFrameView that fills in the fields. This object adds the timing for @@ -899,6 +937,12 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient { EventsMetricsManager events_metrics_manager_; + // Metadata required for drawing a delegated ink trail onto the end of a + // stroke. std::unique_ptr was specifically chosen so that it would be cleared + // as it is forwarded along the pipeline to avoid old information incorrectly + // sticking around and potentially being reused. + std::unique_ptr<viz::DelegatedInkMetadata> delegated_ink_metadata_; + // Used to vend weak pointers to LayerTreeHost to ScopedDeferMainFrameUpdate // objects. base::WeakPtrFactory<LayerTreeHost> defer_main_frame_update_weak_ptr_factory_{ diff --git a/chromium/cc/trees/layer_tree_host_client.h b/chromium/cc/trees/layer_tree_host_client.h index ae48bd94a18..b4b8c607969 100644 --- a/chromium/cc/trees/layer_tree_host_client.h +++ b/chromium/cc/trees/layer_tree_host_client.h @@ -11,6 +11,7 @@ #include "base/time/time.h" #include "cc/input/browser_controls_state.h" #include "cc/metrics/frame_sequence_tracker_collection.h" +#include "services/metrics/public/cpp/ukm_source_id.h" #include "ui/gfx/geometry/scroll_offset.h" #include "ui/gfx/geometry/vector2d_f.h" @@ -101,6 +102,9 @@ class LayerTreeHostClient { virtual void WillUpdateLayers() = 0; virtual void DidUpdateLayers() = 0; + virtual void DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) = 0; // Notification that the proxy started or stopped deferring main frame updates virtual void OnDeferMainFrameUpdatesChanged(bool) = 0; @@ -169,6 +173,12 @@ class LayerTreeHostClient { // RecordEndOfFrameMetrics. virtual std::unique_ptr<BeginMainFrameMetrics> GetBeginMainFrameMetrics() = 0; virtual void NotifyThroughputTrackerResults(CustomTrackerResults results) = 0; + // LayerTreeHost calls this when there is new throughput data. The client send + // the data to the browser process who will aggregate them and report to UKM. + virtual void SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) = 0; protected: virtual ~LayerTreeHostClient() = default; diff --git a/chromium/cc/trees/layer_tree_host_impl.cc b/chromium/cc/trees/layer_tree_host_impl.cc index 4fcc3210311..0fbcdf35620 100644 --- a/chromium/cc/trees/layer_tree_host_impl.cc +++ b/chromium/cc/trees/layer_tree_host_impl.cc @@ -20,6 +20,7 @@ #include "base/debug/crash_logging.h" #include "base/debug/dump_without_crashing.h" #include "base/location.h" +#include "base/logging.h" #include "base/memory/ptr_util.h" #include "base/memory/read_only_shared_memory_region.h" #include "base/metrics/histogram.h" @@ -30,6 +31,7 @@ #include "base/trace_event/traced_value.h" #include "build/build_config.h" #include "cc/base/devtools_instrumentation.h" +#include "cc/base/features.h" #include "cc/base/histograms.h" #include "cc/base/math_util.h" #include "cc/base/switches.h" @@ -40,6 +42,7 @@ #include "cc/input/page_scale_animation.h" #include "cc/input/scroll_elasticity_helper.h" #include "cc/input/scroll_state.h" +#include "cc/input/scroll_utils.h" #include "cc/input/scrollbar.h" #include "cc/input/scrollbar_animation_controller.h" #include "cc/input/scroller_size_metrics.h" @@ -79,7 +82,6 @@ #include "cc/trees/debug_rect_history.h" #include "cc/trees/draw_property_utils.h" #include "cc/trees/effect_node.h" -#include "cc/trees/frame_rate_counter.h" #include "cc/trees/image_animation_controller.h" #include "cc/trees/latency_info_swap_promise_monitor.h" #include "cc/trees/layer_tree_frame_sink.h" @@ -125,6 +127,7 @@ #include "ui/gfx/geometry/scroll_offset.h" #include "ui/gfx/geometry/size_conversions.h" #include "ui/gfx/geometry/vector2d_conversions.h" +#include "ui/gfx/geometry/vector2d_f.h" #include "ui/gfx/skia_util.h" namespace cc { @@ -248,6 +251,41 @@ void PopulateMetadataContentColorUsage( } } +// Registers callbacks, as needed, to track First Scroll Latency. +void ApplyFirstScrollTracking(const ui::LatencyInfo* latency, + uint32_t frame_token, + LayerTreeHostImpl* impl) { + base::TimeTicks creation_timestamp; + // If |latency| isn't tracking a scroll, we don't need to do extra + // first-scroll tracking. + auto scroll_update_started = + ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT; + auto scroll_update_continued = + ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT; + if (!latency->FindLatency(scroll_update_started, &creation_timestamp) && + !latency->FindLatency(scroll_update_continued, &creation_timestamp)) { + return; + } + + // Construct a callback that, given presentation feedback, will report the + // time span between the scroll input-event creation and the + // presentation timestamp. + LayerTreeHost::PresentationTimeCallback presentation_callback = + base::BindOnce( + [](base::TimeTicks event_creation, + LayerTreeHostImpl* layer_tree_host_impl, + const gfx::PresentationFeedback& feedback) { + layer_tree_host_impl->DidObserveScrollDelay( + feedback.timestamp - event_creation, event_creation); + }, + creation_timestamp, impl); + + // Tell the |LayerTreeHostImpl| to run our callback with the presentation + // feedback corresponding to the given |frame_token|. + impl->RegisterCompositorPresentationTimeCallback( + frame_token, std::move(presentation_callback)); +} + // These values are persisted to logs. Entries should not be renumbered and // numeric values should never be reused. enum class SourceIdConsistency : int { @@ -333,8 +371,6 @@ LayerTreeHostImpl::LayerTreeHostImpl( ? std::numeric_limits<size_t>::max() : settings.scheduled_raster_task_limit, settings.ToTileManagerSettings()), - fps_counter_( - FrameRateCounter::Create(task_runner_provider_->HasImplThread())), memory_history_(MemoryHistory::Create()), debug_rect_history_(DebugRectHistory::Create()), mutator_host_(std::move(mutator_host)), @@ -379,12 +415,14 @@ LayerTreeHostImpl::LayerTreeHostImpl( if (!base::CommandLine::ForCurrentProcess()->HasSwitch( switches::kDisableLayerTreeHostMemoryPressure)) { - memory_pressure_listener_.reset( - new base::MemoryPressureListener(base::BindRepeating( - &LayerTreeHostImpl::OnMemoryPressure, base::Unretained(this)))); + memory_pressure_listener_ = std::make_unique<base::MemoryPressureListener>( + FROM_HERE, base::BindRepeating(&LayerTreeHostImpl::OnMemoryPressure, + base::Unretained(this))); } SetDebugState(settings.initial_debug_state); + compositor_frame_reporting_controller_->SetDroppedFrameCounter( + &dropped_frame_counter_); } LayerTreeHostImpl::~LayerTreeHostImpl() { @@ -428,7 +466,6 @@ LayerTreeHostImpl::~LayerTreeHostImpl() { // Clear the UKM Manager so that we do not try to report when the // UKM System has shut down. compositor_frame_reporting_controller_->SetUkmManager(nullptr); - frame_trackers_.SetUkmManager(nullptr); } void LayerTreeHostImpl::WillSendBeginMainFrame() { @@ -1034,6 +1071,7 @@ bool LayerTreeHostImpl::ScrollLayerTo(ElementId element_id, } bool LayerTreeHostImpl::ScrollingShouldSwitchtoMainThread() { + DCHECK(!base::FeatureList::IsEnabled(features::kScrollUnification)); ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree; ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode(); @@ -1550,8 +1588,9 @@ DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) { base::saturated_cast<int>(active_tree_->picture_layers().size()), 1, 400, 20); - // TODO(yigu): Maybe we should use the same check above. Need to figure out - // why exactly we skip 0. + // TODO(pdr): Instead of skipping empty picture layers, maybe we should + // accumulate layer->GetRasterSource()->GetMemoryUsage() above and skip + // recording when the accumulated memory usage is 0. if (!active_tree()->picture_layers().empty()) { UMA_HISTOGRAM_CUSTOM_COUNTS( base::StringPrintf("Compositing.%s.GPUMemoryForTilingsInKb", @@ -1719,7 +1758,7 @@ void LayerTreeHostImpl::ResetTreesForTesting() { } size_t LayerTreeHostImpl::SourceAnimationFrameNumberForTesting() const { - return fps_counter_->current_frame_number(); + return *next_frame_token_; } void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy( @@ -2192,6 +2231,15 @@ viz::CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() { metadata.display_transform_hint = active_tree_->display_transform_hint(); + if (std::unique_ptr<viz::DelegatedInkMetadata> delegated_ink_metadata = + active_tree_->take_delegated_ink_metadata()) { + TRACE_EVENT_INSTANT1( + "cc", "Delegated Ink Metadata set on compositor frame metadata", + TRACE_EVENT_SCOPE_THREAD, "point", + delegated_ink_metadata->point().ToString()); + metadata.delegated_ink_metadata = std::move(delegated_ink_metadata); + } + return metadata; } @@ -2324,6 +2372,19 @@ bool LayerTreeHostImpl::DrawLayers(FrameData* frame) { std::move(compositor_frame), /*hit_test_data_changed=*/false, debug_state_.show_hit_test_borders); + // This is expected to be true roughly every 5 seconds. + if (frame_trackers_.HasThroughputData()) { + ukm::SourceId source_id = ukm_manager_->source_id(); + // source_id can be invalid in tests. + if (source_id != ukm::kInvalidSourceId) { + int aggregated_percent = frame_trackers_.TakeLastAggregatedPercent(); + int impl_percent = frame_trackers_.TakeLastImplPercent(); + base::Optional<int> main_percent = frame_trackers_.TakeLastMainPercent(); + client_->SubmitThroughputData(source_id, aggregated_percent, impl_percent, + main_percent); + } + } + #if DCHECK_IS_ON() if (!doing_sync_draw_) { // The throughput computation (in |FrameSequenceTracker|) depends on the @@ -2387,8 +2448,6 @@ viz::CompositorFrame LayerTreeHostImpl::GenerateCompositorFrame( TRACE_ID_GLOBAL(CurrentBeginFrameArgs().trace_id), TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT, "step", "GenerateCompositorFrame"); - base::TimeTicks frame_time = CurrentBeginFrameArgs().frame_time; - fps_counter_->SaveTimeStamp(frame_time); rendering_stats_instrumentation_->IncrementFrameCount(1); memory_history_->SaveEntry(tile_manager_.memory_stats_from_last_assign()); @@ -2457,6 +2516,8 @@ viz::CompositorFrame LayerTreeHostImpl::GenerateCompositorFrame( if (render_frame_metadata_observer_) { last_draw_render_frame_metadata_ = MakeRenderFrameMetadata(frame); + last_draw_render_frame_metadata_->has_delegated_ink_metadata = + metadata.delegated_ink_metadata.get(); // We cache the value of any new vertical scroll direction so that we can // accurately determine when the next change in vertical scroll direction @@ -2477,6 +2538,8 @@ viz::CompositorFrame LayerTreeHostImpl::GenerateCompositorFrame( base::TimeTicks draw_time = base::TimeTicks::Now(); ukm::SourceId exemplar = metadata.latency_info.front().ukm_source_id(); + ApplyFirstScrollTracking(&metadata.latency_info.front(), + metadata.frame_token, this); bool all_valid = true; bool all_unique = true; for (auto& latency : metadata.latency_info) { @@ -3653,6 +3716,16 @@ void LayerTreeHostImpl::DidChangeBrowserControlsPosition() { SetFullViewportDamage(); } +void LayerTreeHostImpl::DidObserveScrollDelay( + base::TimeDelta scroll_delay, + base::TimeTicks scroll_timestamp) { + // Record First Scroll Delay. + if (!has_observed_first_scroll_delay_) { + client_->DidObserveFirstScrollDelay(scroll_delay, scroll_timestamp); + has_observed_first_scroll_delay_ = true; + } +} + float LayerTreeHostImpl::TopControlsHeight() const { return active_tree_->top_controls_height(); } @@ -3690,20 +3763,43 @@ void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) { input_handler_client_ = client; } -gfx::Vector2dF LayerTreeHostImpl::ResolveScrollPercentageToPixels( +gfx::Vector2dF LayerTreeHostImpl::ResolveScrollGranularityToPixels( const ScrollNode& scroll_node, - const gfx::Vector2dF& scroll_delta) { - gfx::Vector2dF scroll_delta_in_pixels; - scroll_delta_in_pixels.set_x(scroll_delta.x() * - scroll_node.container_bounds.width()); - scroll_delta_in_pixels.set_y(scroll_delta.y() * - scroll_node.container_bounds.height()); - return scroll_delta_in_pixels; + const gfx::Vector2dF& scroll_delta, + ui::ScrollGranularity granularity) { + gfx::Vector2dF pixel_delta = scroll_delta; + + if (granularity == ui::ScrollGranularity::kScrollByPage) { + // Page should use a percentage of the scroller so change the parameters + // and let the percentage case below resolve it. + granularity = ui::ScrollGranularity::kScrollByPercentage; + pixel_delta.Scale(kMinFractionToStepWhenPaging); + } + + if (granularity == ui::ScrollGranularity::kScrollByPercentage) { + gfx::SizeF scroller_size = gfx::SizeF(scroll_node.container_bounds); + + gfx::SizeF viewport_size = + InnerViewportScrollNode() + ? gfx::SizeF(InnerViewportScrollNode()->container_bounds) + : gfx::SizeF(active_tree()->GetDeviceViewport().size()); + + // Convert from rootframe coordinates to screen coordinates (physical + // pixels). + scroller_size.Scale(active_tree()->page_scale_factor_for_scroll()); + + pixel_delta = ScrollUtils::ResolveScrollPercentageToPixels( + scroll_delta, scroller_size, viewport_size); + } + + return pixel_delta; } InputHandler::ScrollStatus LayerTreeHostImpl::TryScroll( const ScrollTree& scroll_tree, ScrollNode* scroll_node) const { + DCHECK(!base::FeatureList::IsEnabled(features::kScrollUnification)); + InputHandler::ScrollStatus scroll_status; scroll_status.main_thread_scrolling_reasons = MainThreadScrollingReason::kNotScrollingOnMain; @@ -3736,9 +3832,9 @@ InputHandler::ScrollStatus LayerTreeHostImpl::TryScroll( } // If an associated scrolling layer is not found, the scroll node must not - // support impl-scrolling. The root, secondary root, and inner viewports are - // all exceptions to this and may not have a layer because it is not required - // for hit testing. + // support impl-scrolling. The root, secondary root, and inner viewports + // are all exceptions to this and may not have a layer because it is not + // required for hit testing. if (scroll_node->id != ScrollTree::kRootNodeId && scroll_node->id != ScrollTree::kSecondaryRootNodeId && !scroll_node->scrolls_inner_viewport && @@ -3804,6 +3900,7 @@ ScrollNode* LayerTreeHostImpl::FindScrollNodeForCompositedScrolling( LayerImpl* layer_impl, bool* scroll_on_main_thread, uint32_t* main_thread_scrolling_reasons) const { + DCHECK(!base::FeatureList::IsEnabled(features::kScrollUnification)); DCHECK(scroll_on_main_thread); DCHECK(main_thread_scrolling_reasons); *main_thread_scrolling_reasons = @@ -3894,7 +3991,13 @@ InputHandler::ScrollStatus LayerTreeHostImpl::RootScrollBegin( scroll_state->data()->set_current_native_scrolling_element( OuterViewportScrollNode()->element_id); - return ScrollBegin(scroll_state, type); + InputHandler::ScrollStatus scroll_status = ScrollBegin(scroll_state, type); + + // Since we provided an ElementId, there should never be a need to perform a + // hit test. + DCHECK(!scroll_status.needs_main_thread_hit_test); + + return scroll_status; } InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin( @@ -3937,59 +4040,145 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin( // this should only happen in ScrollEnd. We should DCHECK here that the state // is cleared instead. https://crbug.com/1016229 ClearCurrentlyScrollingNode(); + auto& scroll_tree = active_tree_->property_trees()->scroll_tree; - if (auto specified_element_id = - scroll_state->data()->current_native_scrolling_element()) { + ElementId target_element_id = scroll_state->target_element_id(); + + if (target_element_id && !scroll_state->is_main_thread_hit_tested()) { + TRACE_EVENT_INSTANT0("cc", "Latched scroll node provided", + TRACE_EVENT_SCOPE_THREAD); // If the caller passed in an element_id we can skip all the hit-testing // bits and provide a node straight-away. - auto& scroll_tree = active_tree_->property_trees()->scroll_tree; - scrolling_node = scroll_tree.FindNodeFromElementId(specified_element_id); - - // We still need to confirm the targeted node exists and can scroll on the - // compositor. - if (scrolling_node) { - scroll_status = TryScroll(active_tree_->property_trees()->scroll_tree, - scrolling_node); - if (IsMainThreadScrolling(scroll_status, scrolling_node)) - scroll_on_main_thread = true; + scrolling_node = scroll_tree.FindNodeFromElementId(target_element_id); + + // In unified scrolling, if we found a node we get to scroll it. + if (!base::FeatureList::IsEnabled(features::kScrollUnification)) { + // We still need to confirm the targeted node exists and can scroll on + // the compositor. + if (scrolling_node) { + scroll_status = TryScroll(active_tree_->property_trees()->scroll_tree, + scrolling_node); + if (IsMainThreadScrolling(scroll_status, scrolling_node)) + scroll_on_main_thread = true; + } } } else { - gfx::Point viewport_point(scroll_state->position_x(), - scroll_state->position_y()); + ScrollNode* starting_node = nullptr; + if (target_element_id) { + TRACE_EVENT_INSTANT0("cc", "Unlatched scroll node provided", + TRACE_EVENT_SCOPE_THREAD); + // We had an element id but we should still perform the walk up the + // scroll tree from the targeted node to latch to a scroller that can + // scroll in the given direction. This mode is only used when scroll + // unification is enabled and the targeted scroller comes back from a + // main thread hit test. + DCHECK(scroll_state->data()->is_main_thread_hit_tested); + DCHECK(base::FeatureList::IsEnabled(features::kScrollUnification)); + starting_node = scroll_tree.FindNodeFromElementId(target_element_id); + + if (!starting_node) { + // The main thread sent us an element_id that the compositor doesn't + // have a scroll node for. This can happen in some racy conditions, a + // freshly created scroller hasn't yet been committed or a + // scroller-destroying commit beats the hit test back to the compositor + // thread. However, these cases shouldn't be user perceptible. + scroll_status.main_thread_scrolling_reasons = + MainThreadScrollingReason::kNoScrollingLayer; + scroll_status.thread = SCROLL_IGNORED; + return scroll_status; + } + } else { + TRACE_EVENT_INSTANT0("cc", "Hit Testing for ScrollNode", + TRACE_EVENT_SCOPE_THREAD); + gfx::Point viewport_point(scroll_state->position_x(), + scroll_state->position_y()); + gfx::PointF device_viewport_point = gfx::ScalePoint( + gfx::PointF(viewport_point), active_tree_->device_scale_factor()); + + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + if (scroll_state->data()->is_main_thread_hit_tested) { + // The client should have discarded the scroll when the hit test came + // back with an invalid element id. If we somehow get here, we should + // drop the scroll as continuing could cause us to infinitely bounce + // back and forth between here and hit testing on the main thread. + NOTREACHED(); + scroll_status.main_thread_scrolling_reasons = + MainThreadScrollingReason::kNoScrollingLayer; + scroll_status.thread = SCROLL_IGNORED; + return scroll_status; + } - gfx::PointF device_viewport_point = gfx::ScalePoint( - gfx::PointF(viewport_point), active_tree_->device_scale_factor()); - LayerImpl* layer_impl = - active_tree_->FindLayerThatIsHitByPoint(device_viewport_point); + // Touch dragging the scrollbar requires falling back to main-thread + // scrolling. + // TODO(bokan): This could be trivially handled in the compositor by + // the new ScrollbarController and should be removed. + { + LayerImpl* first_scrolling_layer_or_scrollbar = + active_tree_->FindFirstScrollingLayerOrScrollbarThatIsHitByPoint( + device_viewport_point); + if (IsTouchDraggingScrollbar(first_scrolling_layer_or_scrollbar, + type)) { + TRACE_EVENT_INSTANT0("cc", "Scrollbar Scrolling", + TRACE_EVENT_SCOPE_THREAD); + scroll_status.thread = SCROLL_ON_MAIN_THREAD; + scroll_status.main_thread_scrolling_reasons = + MainThreadScrollingReason::kScrollbarScrolling; + return scroll_status; + } + } - if (layer_impl) { - LayerImpl* first_scrolling_layer_or_scrollbar = - active_tree_->FindFirstScrollingLayerOrScrollbarThatIsHitByPoint( - device_viewport_point); + ScrollHitTestResult scroll_hit_test = + HitTestScrollNode(device_viewport_point); + + if (!scroll_hit_test.hit_test_successful) { + // This result tells the client that the compositor doesn't have + // enough information to target this scroll. The client should + // perform a hit test in Blink and call this method again, with the + // ElementId of the hit-tested scroll node. + TRACE_EVENT_INSTANT0("cc", "Request Main Thread Hit Test", + TRACE_EVENT_SCOPE_THREAD); + scroll_status.thread = SCROLL_ON_IMPL_THREAD; + scroll_status.needs_main_thread_hit_test = true; + return scroll_status; + } - // Touch dragging the scrollbar requires falling back to main-thread - // scrolling. - if (IsTouchDraggingScrollbar(first_scrolling_layer_or_scrollbar, type)) { - TRACE_EVENT_INSTANT0("cc", "Scrollbar Scrolling", - TRACE_EVENT_SCOPE_THREAD); - scroll_status.thread = SCROLL_ON_MAIN_THREAD; - scroll_status.main_thread_scrolling_reasons = - MainThreadScrollingReason::kScrollbarScrolling; - return scroll_status; - } else if (!IsInitialScrollHitTestReliable( - layer_impl, first_scrolling_layer_or_scrollbar)) { - TRACE_EVENT_INSTANT0("cc", "Failed Hit Test", TRACE_EVENT_SCOPE_THREAD); - scroll_status.thread = SCROLL_UNKNOWN; - scroll_status.main_thread_scrolling_reasons = - MainThreadScrollingReason::kFailedHitTest; - return scroll_status; + starting_node = scroll_hit_test.scroll_node; + } else { + LayerImpl* layer_impl = + active_tree_->FindLayerThatIsHitByPoint(device_viewport_point); + + if (layer_impl) { + LayerImpl* first_scrolling_layer_or_scrollbar = + active_tree_->FindFirstScrollingLayerOrScrollbarThatIsHitByPoint( + device_viewport_point); + + // Touch dragging the scrollbar requires falling back to main-thread + // scrolling. + if (IsTouchDraggingScrollbar(first_scrolling_layer_or_scrollbar, + type)) { + TRACE_EVENT_INSTANT0("cc", "Scrollbar Scrolling", + TRACE_EVENT_SCOPE_THREAD); + scroll_status.thread = SCROLL_ON_MAIN_THREAD; + scroll_status.main_thread_scrolling_reasons = + MainThreadScrollingReason::kScrollbarScrolling; + return scroll_status; + } else if (!IsInitialScrollHitTestReliable( + layer_impl, first_scrolling_layer_or_scrollbar)) { + TRACE_EVENT_INSTANT0("cc", "Failed Hit Test", + TRACE_EVENT_SCOPE_THREAD); + scroll_status.thread = SCROLL_UNKNOWN; + scroll_status.main_thread_scrolling_reasons = + MainThreadScrollingReason::kFailedHitTest; + return scroll_status; + } + } + + starting_node = FindScrollNodeForCompositedScrolling( + device_viewport_point, layer_impl, &scroll_on_main_thread, + &scroll_status.main_thread_scrolling_reasons); } } - ScrollNode* starting_node = FindScrollNodeForCompositedScrolling( - device_viewport_point, layer_impl, &scroll_on_main_thread, - &scroll_status.main_thread_scrolling_reasons); - // The above finds the ScrollNode that's hit by the given point but we // still need to walk up the scroll tree looking for the first node that // can consume delta from the scroll state. @@ -3997,6 +4186,10 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin( } if (scroll_on_main_thread) { + // Under scroll unification we can request a main thread hit test, but we + // should never send scrolls to the main thread. + DCHECK(!base::FeatureList::IsEnabled(features::kScrollUnification)); + RecordCompositorSlowScrollMetric(type, MAIN_THREAD); scroll_status.thread = SCROLL_ON_MAIN_THREAD; return scroll_status; @@ -4004,11 +4197,20 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin( scroll_status.main_thread_scrolling_reasons = MainThreadScrollingReason::kNoScrollingLayer; if (settings_.is_layer_tree_for_subframe) { + // OOPIFs never have a viewport scroll node so if we can't scroll + // we need to be bubble up to the parent frame. This happens by + // returning SCROLL_UNKNOWN. TRACE_EVENT_INSTANT0("cc", "Ignored - No ScrollNode (OOPIF)", TRACE_EVENT_SCOPE_THREAD); scroll_status.thread = SCROLL_UNKNOWN; } else { - TRACE_EVENT_INSTANT0("cc", "Ignroed - No ScrollNode", + // If we didn't hit a layer above we'd usually fallback to the + // viewport scroll node. However, there may not be one if a scroll + // is received before the root layer has been attached. Chrome now + // drops input until the first commit is received so this probably + // can't happen in a typical browser session but there may still be + // configurations where input is allowed prior to a commit. + TRACE_EVENT_INSTANT0("cc", "Ignored - No ScrollNode", TRACE_EVENT_SCOPE_THREAD); scroll_status.thread = SCROLL_IGNORED; } @@ -4034,13 +4236,22 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin( return scroll_status; } -ScrollNode* LayerTreeHostImpl::HitTestScrollNode( +LayerTreeHostImpl::ScrollHitTestResult LayerTreeHostImpl::HitTestScrollNode( const gfx::PointF& device_viewport_point) const { + ScrollHitTestResult result; + result.scroll_node = nullptr; + result.hit_test_successful = false; + LayerImpl* layer_impl = active_tree_->FindLayerThatIsHitByPoint(device_viewport_point); - if (!layer_impl) - return nullptr; + if (!layer_impl) { + result.hit_test_successful = true; + if (InnerViewportScrollNode()) + result.scroll_node = GetNodeToScroll(InnerViewportScrollNode()); + + return result; + } // There are some cases where the hit layer may not be correct (e.g. layer // squashing). If we detect this case, we can't target a scroll node here. @@ -4052,10 +4263,19 @@ ScrollNode* LayerTreeHostImpl::HitTestScrollNode( if (!IsInitialScrollHitTestReliable(layer_impl, first_scrolling_layer_or_scrollbar)) { TRACE_EVENT_INSTANT0("cc", "Failed Hit Test", TRACE_EVENT_SCOPE_THREAD); - return nullptr; + return result; } } + // If we hit a non-fast scrollable region, that means there's some reason we + // can't scroll in this region. Primarily, because there's another scroller + // there that isn't composited and we don't know about so we'll return + // nullptr in that case. + if (active_tree_->PointHitsNonFastScrollableRegion(device_viewport_point, + *layer_impl)) { + return result; + } + // If we hit a scrollbar layer, get the ScrollNode from its associated // scrolling layer, rather than directly from the scrollbar layer. The latter // would return the parent scroller's ScrollNode. @@ -4068,7 +4288,9 @@ ScrollNode* LayerTreeHostImpl::HitTestScrollNode( ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree; ScrollNode* scroll_node = scroll_tree.Node(layer_impl->scroll_tree_index()); - return GetNodeToScroll(scroll_node); + result.scroll_node = GetNodeToScroll(scroll_node); + result.hit_test_successful = true; + return result; } // Requires falling back to main thread scrolling when it hit tests in scrollbar @@ -4602,10 +4824,9 @@ bool LayerTreeHostImpl::CanConsumeDelta(const ScrollState& scroll_state, return false; } delta_to_scroll = local_scroll_delta; - } else if (scroll_state.delta_granularity() == - ui::ScrollGranularity::kScrollByPercentage) { - delta_to_scroll = - ResolveScrollPercentageToPixels(scroll_node, delta_to_scroll); + } else { + delta_to_scroll = ResolveScrollGranularityToPixels( + scroll_node, delta_to_scroll, scroll_state.delta_granularity()); } if (ComputeScrollDelta(scroll_node, delta_to_scroll) != gfx::Vector2dF()) @@ -4656,21 +4877,27 @@ InputHandlerScrollResult LayerTreeHostImpl::ScrollUpdate( // The current_native_scrolling_element should only be set for ScrollBegin. DCHECK(!scroll_state->data()->current_native_scrolling_element()); + TRACE_EVENT2("cc", "LayerTreeHostImpl::ScrollUpdate", "dx", + scroll_state->delta_x(), "dy", scroll_state->delta_y()); if (!CurrentlyScrollingNode()) return InputHandlerScrollResult(); last_scroll_update_state_ = *scroll_state; - bool is_delta_percent_units = scroll_state->delta_granularity() == - ui::ScrollGranularity::kScrollByPercentage; - if (is_delta_percent_units) { - gfx::Vector2dF resolvedScrollDelta = ResolveScrollPercentageToPixels( - *CurrentlyScrollingNode(), - gfx::Vector2dF(scroll_state->delta_x(), scroll_state->delta_y())); - - scroll_state->data()->delta_x = resolvedScrollDelta.x(); - scroll_state->data()->delta_y = resolvedScrollDelta.y(); + gfx::Vector2dF resolvedScrollDelta = ResolveScrollGranularityToPixels( + *CurrentlyScrollingNode(), + gfx::Vector2dF(scroll_state->delta_x(), scroll_state->delta_y()), + scroll_state->delta_granularity()); + + scroll_state->data()->delta_x = resolvedScrollDelta.x(); + scroll_state->data()->delta_y = resolvedScrollDelta.y(); + // The decision of whether or not we'll animate a scroll comes down to + // whether the granularity is specified in precise pixels or not. Thus we + // need to preserve a precise granularity if that's what was specified; all + // others are animated and so can be resolved to regular pixels. + if (scroll_state->delta_granularity() != + ui::ScrollGranularity::kScrollByPrecisePixel) { scroll_state->data()->delta_granularity = ui::ScrollGranularity::kScrollByPixel; } @@ -4994,9 +5221,6 @@ void LayerTreeHostImpl::RecordScrollBegin( ScrollBeginThreadState scroll_start_state) { auto tracker_type = GetTrackerTypeForScroll(input_type); DCHECK_NE(tracker_type, FrameSequenceTrackerType::kMaxType); - auto* metrics = frame_trackers_.StartSequence(tracker_type); - if (!metrics) - return; // The main-thread is the 'scrolling thread' if: // (1) the scroll is driven by the main thread, or @@ -5015,7 +5239,7 @@ void LayerTreeHostImpl::RecordScrollBegin( scrolling_thread = FrameSequenceMetrics::ThreadType::kMain; break; } - metrics->SetScrollingThread(scrolling_thread); + frame_trackers_.StartScrollSequence(tracker_type, scrolling_thread); } void LayerTreeHostImpl::RecordScrollEnd(ui::ScrollInputType input_type) { @@ -5078,11 +5302,14 @@ InputHandlerPointerResult LayerTreeHostImpl::MouseMoveAt( gfx::PointF device_viewport_point = gfx::ScalePoint( gfx::PointF(viewport_point), active_tree_->device_scale_factor()); - ScrollNode* scroll_node = HitTestScrollNode(device_viewport_point); + + ScrollHitTestResult hit_test = HitTestScrollNode(device_viewport_point); + + ScrollNode* scroll_node = hit_test.scroll_node; // The hit test can fail in some cases, e.g. we don't know if a region of a // squashed layer has content or is empty. - if (!scroll_node) + if (!hit_test.hit_test_successful || !scroll_node) return result; // Scrollbars for the viewport are registered with the outer viewport layer. @@ -5242,6 +5469,9 @@ std::unique_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() { scroll_info->overscroll_delta = overscroll_delta_for_main_thread_; overscroll_delta_for_main_thread_ = gfx::Vector2dF(); + scroll_info->ongoing_scroll_animation = + !!mutator_host_->ImplOnlyScrollAnimatingElement(); + // Use the |last_latched_scroller_| rather than the |CurrentlyScrollingNode| // since the latter may be cleared by a GSE before we've committed these // values to the main thread. @@ -5398,9 +5628,10 @@ void LayerTreeHostImpl::RegisterScrollbarAnimationController( } void LayerTreeHostImpl::DidUnregisterScrollbarLayer( - ElementId scroll_element_id) { + ElementId scroll_element_id, + ScrollbarOrientation orientation) { scrollbar_animation_controllers_.erase(scroll_element_id); - scrollbar_controller_->DidUnregisterScrollbar(scroll_element_id); + scrollbar_controller_->DidUnregisterScrollbar(scroll_element_id, orientation); } ScrollbarAnimationController* @@ -6230,7 +6461,7 @@ void LayerTreeHostImpl::InitializeUkm( void LayerTreeHostImpl::SetActiveURL(const GURL& url, ukm::SourceId source_id) { tile_manager_.set_active_url(url); - + has_observed_first_scroll_delay_ = false; // The active tree might still be from content for the previous page when the // recorder is updated here, since new content will be pushed with the next // main frame. But we should only get a few impl frames wrong here in that diff --git a/chromium/cc/trees/layer_tree_host_impl.h b/chromium/cc/trees/layer_tree_host_impl.h index f7ce4e673e6..47dcba6decb 100644 --- a/chromium/cc/trees/layer_tree_host_impl.h +++ b/chromium/cc/trees/layer_tree_host_impl.h @@ -29,6 +29,7 @@ #include "cc/input/scrollbar_animation_controller.h" #include "cc/input/scrollbar_controller.h" #include "cc/layers/layer_collections.h" +#include "cc/metrics/dropped_frame_counter.h" #include "cc/metrics/event_metrics.h" #include "cc/metrics/events_metrics_manager.h" #include "cc/metrics/frame_sequence_tracker_collection.h" @@ -83,7 +84,6 @@ class BrowserControlsOffsetManager; class CompositorFrameReportingController; class DebugRectHistory; class EvictionTilePriorityQueue; -class FrameRateCounter; class ImageAnimationController; class LCDTextMetricsReporter; class LayerImpl; @@ -176,6 +176,17 @@ class LayerTreeHostImplClient { virtual void NotifyThroughputTrackerResults(CustomTrackerResults results) = 0; + // Send the throughput data to the main thread's LayerTreeHostClient, which + // then send the data to the browser process and eventually report to UKM. + virtual void SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) = 0; + + virtual void DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) = 0; + protected: virtual ~LayerTreeHostImplClient() = default; }; @@ -333,6 +344,8 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, float CurrentTopControlsShownRatio() const override; float CurrentBottomControlsShownRatio() const override; void DidChangeBrowserControlsPosition() override; + void DidObserveScrollDelay(base::TimeDelta scroll_delay, + base::TimeTicks scroll_timestamp); bool HaveRootScrollNode() const override; void SetNeedsCommit() override; @@ -469,7 +482,8 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, void RegisterScrollbarAnimationController(ElementId scroll_element_id, float initial_opacity); - void DidUnregisterScrollbarLayer(ElementId scroll_element_id); + void DidUnregisterScrollbarLayer(ElementId scroll_element_id, + ScrollbarOrientation orientation); ScrollbarAnimationController* ScrollbarAnimationControllerForElementId( ElementId scroll_element_id) const; void FlashAllScrollbars(bool did_scroll); @@ -610,7 +624,8 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, const ScrollNode* CurrentlyScrollingNode() const; bool scroll_affects_scroll_handler() const { - return scroll_affects_scroll_handler_; + return settings_.enable_synchronized_scrolling && + scroll_affects_scroll_handler_; } void QueueSwapPromiseForMainThreadScrollUpdate( std::unique_ptr<SwapPromise> swap_promise); @@ -641,9 +656,8 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, const gfx::Transform& DrawTransform() const; std::unique_ptr<ScrollAndScaleSet> ProcessScrollDeltas(); - FrameRateCounter* fps_counter() { return fps_counter_.get(); } - base::Optional<int> current_universal_throughput() { - return frame_trackers_.current_universal_throughput(); + DroppedFrameCounter* dropped_frame_counter() { + return &dropped_frame_counter_; } MemoryHistory* memory_history() { return memory_history_.get(); } DebugRectHistory* debug_rect_history() { return debug_rect_history_.get(); } @@ -735,6 +749,13 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, gfx::Vector2dF ComputeScrollDelta(const ScrollNode& scroll_node, const gfx::Vector2dF& delta); + // Resolves a delta in the given granularity for the |scroll_node| into + // physical pixels to scroll. + gfx::Vector2dF ResolveScrollGranularityToPixels( + const ScrollNode& scroll_node, + const gfx::Vector2dF& scroll_delta, + ui::ScrollGranularity granularity); + void ScheduleMicroBenchmark(std::unique_ptr<MicroBenchmarkImpl> benchmark); viz::CompositorFrameMetadata MakeCompositorFrameMetadata(); @@ -785,15 +806,6 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, : task_runner_provider_->MainThreadTaskRunner(); } - // Determines whether the given scroll node can scroll on the compositor - // thread or if there are any reasons it must be scrolled on the main thread - // or not at all. Note: in general, this is not sufficient to determine if a - // scroll can occur on the compositor thread. If hit testing to a scroll - // node, the caller must also check whether the hit point intersects a - // non-fast-scrolling-region of any ancestor scrolling layers. - InputHandler::ScrollStatus TryScroll(const ScrollTree& scroll_tree, - ScrollNode* scroll_node) const; - // Return all ScrollNode indices that have an associated layer with a non-fast // region that intersects the point. base::flat_set<int> NonFastScrollableNodes( @@ -894,14 +906,20 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, void CollectScrollDeltas(ScrollAndScaleSet* scroll_info); void CollectScrollbarUpdates(ScrollAndScaleSet* scroll_info) const; - gfx::Vector2dF ResolveScrollPercentageToPixels( - const ScrollNode& scroll_node, - const gfx::Vector2dF& resolved_pixels); - // Returns the ScrollNode we should use to scroll, accounting for viewport // scroll chaining rules. ScrollNode* GetNodeToScroll(ScrollNode* node) const; + // Determines whether the given scroll node can scroll on the compositor + // thread or if there are any reasons it must be scrolled on the main thread + // or not at all. Note: in general, this is not sufficient to determine if a + // scroll can occur on the compositor thread. If hit testing to a scroll + // node, the caller must also check whether the hit point intersects a + // non-fast-scrolling-region of any ancestor scrolling layers. Can be removed + // after scroll unification https://crbug.com/476553. + InputHandler::ScrollStatus TryScroll(const ScrollTree& scroll_tree, + ScrollNode* scroll_node) const; + // Transforms viewport start point and scroll delta to local start point and // local delta, respectively. If the transformation of either the start or end // point of a scroll is clipped, the function returns false. @@ -957,13 +975,14 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, LayerImpl* first_scrolling_layer_or_drawn_scrollbar, ui::ScrollInputType type); - // Initial scroll hit testing can be unreliable in the presence of squashed - // layers. In this case, we fall back to main thread scrolling. This function - // compares |layer_impl| returned from a regular hit test to the layer - // returned from a hit test performed only on scrollers and scrollbars. If the - // closest scrolling ancestor of |layer_impl| is not the other layer, then the - // layer_impl must be a squasing layer overtop of some other scroller and we - // must rely on the main thread. + // |layer| is returned from a regular hit test, and + // |first_scrolling_layer_or_drawn_scrollbar| is returned from a hit test + // performed only on scrollers and scrollbars. Initial scroll hit testing can + // be unreliable if the latter is not the direct scroll ancestor of the + // former. In this case, we will fall back to main thread scrolling because + // the compositor thread doesn't know which layer to scroll. This happens when + // a layer covers a scroller that doesn't scroll the former, or a scroller is + // masked by a mask layer for mask image, clip-path, rounded border, etc. // // Note, position: fixed layers use the inner viewport as their ScrollNode // (since they don't scroll with the outer viewport), however, scrolls from @@ -1018,21 +1037,35 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, void ClearCurrentlyScrollingNode(); // Performs a hit test to determine the ScrollNode to use when scrolling at - // |viewport_point|. Can return nullptr if the hit test fails; see the - // comment in IsInitialScrollHitTestReliable - ScrollNode* HitTestScrollNode(const gfx::PointF& device_viewport_point) const; + // |viewport_point|. If no layer is hit, this falls back to the inner + // viewport scroll node. Returns: + // - If |hit_test_sucessful| is false, hit testing has failed and the + // compositor cannot determine the correct scroll node (e.g. see comments in + // IsInitialScrollHitTestReliable). |scroll_node| is always nullptr in this + // case. + // - If |hit_test_successful| is true, returns the ScrollNode to use in + // |scroll_node|. This can be nullptr if no layer was hit and there are no + // viewport nodes (e.g. OOPIF, UI compositor). + struct ScrollHitTestResult { + ScrollNode* scroll_node; + bool hit_test_successful; + }; + ScrollHitTestResult HitTestScrollNode( + const gfx::PointF& device_viewport_point) const; // Similar to above but includes complicated logic to determine whether the // ScrollNode is able to be scrolled on the compositor or requires main // thread scrolling. If main thread scrolling is required // |scroll_on_main_thread| is set to true and the reason is given in // |main_thread_scrolling_reason| to on of the enum values in - // main_thread_scrolling_reason.h. + // main_thread_scrolling_reason.h. Can be removed after scroll unification + // https://crbug.com/476553. ScrollNode* FindScrollNodeForCompositedScrolling( const gfx::PointF& device_viewport_point, LayerImpl* layer_hit_by_point, bool* scroll_on_main_thread, uint32_t* main_thread_scrolling_reason) const; + void StartScrollbarFadeRecursive(LayerImpl* layer); void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy); @@ -1226,7 +1259,7 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, std::unique_ptr<PageScaleAnimation> page_scale_animation_; - std::unique_ptr<FrameRateCounter> fps_counter_; + DroppedFrameCounter dropped_frame_counter_; std::unique_ptr<MemoryHistory> memory_history_; std::unique_ptr<DebugRectHistory> debug_rect_history_; @@ -1400,6 +1433,7 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler, std::unique_ptr<LCDTextMetricsReporter> lcd_text_metrics_reporter_; FrameRateEstimator frame_rate_estimator_; + bool has_observed_first_scroll_delay_ = false; // Must be the last member to ensure this is destroyed first in the // destruction order and invalidates all weak pointers. diff --git a/chromium/cc/trees/layer_tree_host_impl_unittest.cc b/chromium/cc/trees/layer_tree_host_impl_unittest.cc index 3d1cfc76a5d..fd82323bf7e 100644 --- a/chromium/cc/trees/layer_tree_host_impl_unittest.cc +++ b/chromium/cc/trees/layer_tree_host_impl_unittest.cc @@ -27,10 +27,12 @@ #include "cc/animation/animation_host.h" #include "cc/animation/animation_id_provider.h" #include "cc/animation/transform_operations.h" +#include "cc/base/features.h" #include "cc/base/histograms.h" #include "cc/input/browser_controls_offset_manager.h" #include "cc/input/main_thread_scrolling_reason.h" #include "cc/input/page_scale_animation.h" +#include "cc/input/scroll_utils.h" #include "cc/layers/append_quads_data.h" #include "cc/layers/heads_up_display_layer_impl.h" #include "cc/layers/layer_impl.h" @@ -262,7 +264,16 @@ class LayerTreeHostImplTest : public testing::Test, void NotifyPaintWorkletStateChange( Scheduler::PaintWorkletState state) override {} void NotifyThroughputTrackerResults(CustomTrackerResults results) override {} + void SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) override {} + void DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) override { + first_scroll_observed++; + } void set_reduce_memory_result(bool reduce_memory_result) { reduce_memory_result_ = reduce_memory_result; } @@ -496,15 +507,21 @@ class LayerTreeHostImplTest : public testing::Test, layer_tree_impl->DidBecomeActive(); // The point hits squash1 layer and also scroll layer, because scroll layer - // is not an ancestor of squash1 layer, we cannot scroll on impl thread. + // is not an ancestor of squash1 layer, we cannot scroll on impl thread + // (without at least a hit test on the main thread). InputHandler::ScrollStatus status = host_impl_->ScrollBegin( BeginState(gfx::Point(230, 150), gfx::Vector2dF(0, 10), ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - ASSERT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); - ASSERT_EQ(MainThreadScrollingReason::kFailedHitTest, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + ASSERT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + ASSERT_TRUE(status.needs_main_thread_hit_test); + } else { + ASSERT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); + ASSERT_EQ(MainThreadScrollingReason::kFailedHitTest, + status.main_thread_scrolling_reasons); + } // The point hits squash1 layer and also scrollbar layer. status = host_impl_->ScrollBegin( @@ -512,9 +529,14 @@ class LayerTreeHostImplTest : public testing::Test, ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - ASSERT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); - ASSERT_EQ(MainThreadScrollingReason::kFailedHitTest, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + ASSERT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + ASSERT_TRUE(status.needs_main_thread_hit_test); + } else { + ASSERT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); + ASSERT_EQ(MainThreadScrollingReason::kFailedHitTest, + status.main_thread_scrolling_reasons); + } // The point hits squash2 layer and also scroll layer, because scroll layer // is an ancestor of squash2 layer, we should scroll on impl. @@ -670,8 +692,8 @@ class LayerTreeHostImplTest : public testing::Test, host_impl_ = nullptr; } - void WhiteListedTouchActionTestHelper(float device_scale_factor, - float page_scale_factor) { + void AllowedTouchActionTestHelper(float device_scale_factor, + float page_scale_factor) { SetupViewportLayersInnerScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); DrawFrame(); @@ -825,6 +847,26 @@ class LayerTreeHostImplTest : public testing::Test, scoped_refptr<AnimationTimeline> timeline_; std::unique_ptr<base::Thread> image_worker_; int next_layer_id_ = 2; + int first_scroll_observed = 0; +}; + +// Allows parameterizing the above class on the scroll unification flag. We +// can't parameterize the base class itself because it serves as a base to +// other parameterized descendants. Can be removed when unification ships. +class ScrollUnifiedLayerTreeHostImplTest + : public LayerTreeHostImplTest, + public testing::WithParamInterface<bool> { + public: + ScrollUnifiedLayerTreeHostImplTest() { + if (GetParam()) { + scoped_feature_list.InitAndEnableFeature(features::kScrollUnification); + } else { + scoped_feature_list.InitAndDisableFeature(features::kScrollUnification); + } + } + + private: + base::test::ScopedFeatureList scoped_feature_list; }; class CommitToPendingTreeLayerTreeHostImplTest : public LayerTreeHostImplTest { @@ -901,7 +943,11 @@ class TestInputHandlerClient : public InputHandlerClient { float max_page_scale_factor_; }; -TEST_F(LayerTreeHostImplTest, LocalAndExternalPinchState) { +INSTANTIATE_TEST_SUITE_P(All, + ScrollUnifiedLayerTreeHostImplTest, + testing::Bool()); + +TEST_P(ScrollUnifiedLayerTreeHostImplTest, LocalAndExternalPinchState) { // PinchGestureBegin/End update pinch_gesture_active() properly. EXPECT_FALSE(host_impl_->pinch_gesture_active()); host_impl_->PinchGestureBegin(); @@ -925,7 +971,7 @@ TEST_F(LayerTreeHostImplTest, LocalAndExternalPinchState) { EXPECT_FALSE(host_impl_->pinch_gesture_active()); } -TEST_F(LayerTreeHostImplTest, NotifyIfCanDrawChanged) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, NotifyIfCanDrawChanged) { // Note: It is not possible to disable the renderer once it has been set, // so we do not need to test that disabling the renderer notifies us // that can_draw changed. @@ -961,7 +1007,7 @@ TEST_F(LayerTreeHostImplTest, NotifyIfCanDrawChanged) { on_can_draw_state_changed_called_ = false; } -TEST_F(LayerTreeHostImplTest, ResourcelessDrawWithEmptyViewport) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ResourcelessDrawWithEmptyViewport) { CreateHostImpl(DefaultSettings(), FakeLayerTreeFrameSink::CreateSoftware()); SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); @@ -979,7 +1025,7 @@ TEST_F(LayerTreeHostImplTest, ResourcelessDrawWithEmptyViewport) { ASSERT_EQ(fake_layer_tree_frame_sink->num_sent_frames(), 1u); } -TEST_F(LayerTreeHostImplTest, ScrollDeltaNoLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollDeltaNoLayers) { host_impl_->active_tree()->SetRootLayerForTesting(nullptr); std::unique_ptr<ScrollAndScaleSet> scroll_info = @@ -987,7 +1033,7 @@ TEST_F(LayerTreeHostImplTest, ScrollDeltaNoLayers) { ASSERT_EQ(scroll_info->scrolls.size(), 0u); } -TEST_F(LayerTreeHostImplTest, ScrollDeltaTreeButNoChanges) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollDeltaTreeButNoChanges) { LayerImpl* root = SetupDefaultRootLayer(gfx::Size(10, 10)); { LayerImpl* child1 = AddLayer(); @@ -1015,7 +1061,7 @@ TEST_F(LayerTreeHostImplTest, ScrollDeltaTreeButNoChanges) { ExpectClearedScrollDeltasRecursive(root); } -TEST_F(LayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) { gfx::ScrollOffset scroll_offset(20, 30); gfx::ScrollOffset scroll_delta(11, -15); @@ -1075,7 +1121,9 @@ TEST_F(CommitToPendingTreeLayerTreeHostImplTest, "Compositing.Renderer.GPUMemoryForTilingsInKb", 1); } -TEST_F(LayerTreeHostImplTest, ScrollBeforeRootLayerAttached) { +// This test verifies that we drop a scroll (and don't crash) if a scroll is +// received before the root layer has been attached. https://crbug.com/895817. +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollBeforeRootLayerAttached) { InputHandler::ScrollStatus status = host_impl_->ScrollBegin(BeginState(gfx::Point(), gfx::Vector2dF(0, 1), ui::ScrollInputType::kWheel) @@ -1100,7 +1148,7 @@ TEST_F(LayerTreeHostImplTest, ScrollBeforeRootLayerAttached) { // to pre-commit input deferral which causes some input events to be dropped // before the first commit in a renderer has occurred. See the flag // kAllowPreCommitInput and how it's used. -TEST_F(LayerTreeHostImplTest, ScrollUpdateAndEndNoOpWithoutBegin) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollUpdateAndEndNoOpWithoutBegin) { SetupViewportLayersOuterScrolls(gfx::Size(100, 100), gfx::Size(1000, 1000)); // Simulate receiving a gesture mid-stream so that the Begin wasn't ever @@ -1141,7 +1189,7 @@ TEST_F(LayerTreeHostImplTest, ScrollUpdateAndEndNoOpWithoutBegin) { // Test that specifying a scroller to ScrollBegin (i.e. avoid hit testing) // returns the correct status if the scroller cannot be scrolled on the // compositor thread. -TEST_F(LayerTreeHostImplTest, TargetMainThreadScroller) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, TargetMainThreadScroller) { SetupViewportLayersOuterScrolls(gfx::Size(100, 100), gfx::Size(1000, 1000)); ScrollStateData scroll_state_data; @@ -1160,22 +1208,32 @@ TEST_F(LayerTreeHostImplTest, TargetMainThreadScroller) { } // Now add a MainThreadScrollingReason. Trying to target the node this time - // should result in a failed ScrollBegin with the appropriate return value. + // should result in a failed ScrollBegin with the appropriate return value, + // unless scroll unification is enabled - since all nodes can be scrolled + // from the compositor in that mode. host_impl_->OuterViewportScrollNode()->main_thread_scrolling_reasons = MainThreadScrollingReason::kThreadedScrollingDisabled; { InputHandler::ScrollStatus status = host_impl_->ScrollBegin( scroll_state.get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ( - host_impl_->OuterViewportScrollNode()->main_thread_scrolling_reasons, - status.main_thread_scrolling_reasons); - EXPECT_FALSE(host_impl_->CurrentlyScrollingNode()); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + EXPECT_EQ( + MainThreadScrollingReason::kThreadedScrollingDisabled, + host_impl_->CurrentlyScrollingNode()->main_thread_scrolling_reasons); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ( + host_impl_->OuterViewportScrollNode()->main_thread_scrolling_reasons, + status.main_thread_scrolling_reasons); + EXPECT_FALSE(host_impl_->CurrentlyScrollingNode()); + } } } -TEST_F(LayerTreeHostImplTest, ScrollRootCallsCommitAndRedraw) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollRootCallsCommitAndRedraw) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -1206,7 +1264,8 @@ TEST_F(LayerTreeHostImplTest, ScrollRootCallsCommitAndRedraw) { // makes some sense since touchscreen/high-precision touchpad scrolling has a // physical metaphor (movement sticks to finger) so smoothness should be // prioritized. -TEST_F(LayerTreeHostImplTest, ActivelyTouchScrollingOnlyAfterScrollMovement) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ActivelyTouchScrollingOnlyAfterScrollMovement) { SetupViewportLayersOuterScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -1287,7 +1346,7 @@ TEST_F(LayerTreeHostImplTest, ActivelyTouchScrollingOnlyAfterScrollMovement) { } } -TEST_F(LayerTreeHostImplTest, ScrollWithoutRootLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollWithoutRootLayer) { // We should not crash when trying to scroll an empty layer tree. InputHandler::ScrollStatus status = host_impl_->ScrollBegin(BeginState(gfx::Point(), gfx::Vector2dF(0, 10), @@ -1299,7 +1358,7 @@ TEST_F(LayerTreeHostImplTest, ScrollWithoutRootLayer) { status.main_thread_scrolling_reasons); } -TEST_F(LayerTreeHostImplTest, ScrollWithoutRenderer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollWithoutRenderer) { auto gl_owned = std::make_unique<viz::TestGLES2Interface>(); gl_owned->LoseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB); @@ -1323,7 +1382,7 @@ TEST_F(LayerTreeHostImplTest, ScrollWithoutRenderer) { status.main_thread_scrolling_reasons); } -TEST_F(LayerTreeHostImplTest, ReplaceTreeWhileScrolling) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ReplaceTreeWhileScrolling) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -1356,7 +1415,8 @@ TEST_F(LayerTreeHostImplTest, ReplaceTreeWhileScrolling) { scroll_delta)); } -TEST_F(LayerTreeHostImplTest, ActivateTreeScrollingNodeDisappeared) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ActivateTreeScrollingNodeDisappeared) { SetupViewportLayersOuterScrolls(gfx::Size(100, 100), gfx::Size(1000, 1000)); auto status = host_impl_->ScrollBegin( @@ -1385,7 +1445,7 @@ TEST_F(LayerTreeHostImplTest, ActivateTreeScrollingNodeDisappeared) { EXPECT_FALSE(host_impl_->active_tree()->CurrentlyScrollingNode()); } -TEST_F(LayerTreeHostImplTest, ScrollBlocksOnWheelEventHandlers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollBlocksOnWheelEventHandlers) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); auto* scroll = InnerViewportScrollLayer(); scroll->SetWheelEventHandlerRegion(Region(gfx::Rect(20, 20))); @@ -1415,7 +1475,7 @@ TEST_F(LayerTreeHostImplTest, ScrollBlocksOnWheelEventHandlers) { host_impl_->ScrollEnd(); } -TEST_F(LayerTreeHostImplTest, ScrollBlocksOnTouchEventHandlers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollBlocksOnTouchEventHandlers) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -1467,9 +1527,9 @@ TEST_F(LayerTreeHostImplTest, ScrollBlocksOnTouchEventHandlers) { EXPECT_EQ(TouchAction::kPanX, touch_action); } -TEST_F(LayerTreeHostImplTest, ShouldScrollOnMainThread) { - SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); - host_impl_->InnerViewportScrollNode()->main_thread_scrolling_reasons = +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ShouldScrollOnMainThread) { + SetupViewportLayersOuterScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); + host_impl_->OuterViewportScrollNode()->main_thread_scrolling_reasons = MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects; DrawFrame(); @@ -1478,30 +1538,48 @@ TEST_F(LayerTreeHostImplTest, ShouldScrollOnMainThread) { ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + EXPECT_EQ( + MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, + host_impl_->CurrentlyScrollingNode()->main_thread_scrolling_reasons); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, + status.main_thread_scrolling_reasons); + } status = host_impl_->ScrollBegin(BeginState(gfx::Point(), gfx::Vector2d(0, 10), ui::ScrollInputType::kTouchscreen) .get(), ui::ScrollInputType::kTouchscreen); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + EXPECT_EQ( + MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, + host_impl_->CurrentlyScrollingNode()->main_thread_scrolling_reasons); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, + status.main_thread_scrolling_reasons); + } } -TEST_F(LayerTreeHostImplTest, ScrollWithOverlappingNonScrollableLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollWithOverlappingNonScrollableLayer) { CreateAndTestNonScrollableLayers(false); } -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollWithOverlappingTransparentNonScrollableLayer) { CreateAndTestNonScrollableLayers(true); } -TEST_F(LayerTreeHostImplTest, ScrolledOverlappingDrawnScrollbarLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrolledOverlappingDrawnScrollbarLayer) { LayerTreeImpl* layer_tree_impl = host_impl_->active_tree(); gfx::Size content_size = gfx::Size(360, 600); gfx::Size scroll_content_size = gfx::Size(345, 3800); @@ -1534,9 +1612,16 @@ TEST_F(LayerTreeHostImplTest, ScrolledOverlappingDrawnScrollbarLayer) { ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, + status.main_thread_scrolling_reasons); + EXPECT_TRUE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest, + status.main_thread_scrolling_reasons); + } // The point hits the drawn scrollbar layer completely and should scroll on // the impl thread. @@ -1623,7 +1708,7 @@ TEST_F(LayerTreeHostImplTestInvokeMainThreadCallbacks, mock_details.presentation_feedback); } -TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionBasic) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, NonFastScrollableRegionBasic) { SetupViewportLayersInnerScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); LayerImpl* outer_scroll = OuterViewportScrollLayer(); @@ -1631,24 +1716,40 @@ TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionBasic) { DrawFrame(); - // All scroll types inside the non-fast scrollable region should fail. + // All scroll types inside the non-fast scrollable region should fail. When + // scroll unification is enabled, these scrolls succeed but request a main + // thread hit test. InputHandler::ScrollStatus status = host_impl_->ScrollBegin( BeginState(gfx::Point(25, 25), gfx::Vector2d(0, 10), ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, + status.main_thread_scrolling_reasons); + EXPECT_TRUE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, + status.main_thread_scrolling_reasons); + } status = host_impl_->ScrollBegin( BeginState(gfx::Point(25, 25), gfx::Vector2d(0, 10), ui::ScrollInputType::kTouchscreen) .get(), ui::ScrollInputType::kTouchscreen); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, + status.main_thread_scrolling_reasons); + EXPECT_TRUE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, + status.main_thread_scrolling_reasons); + } // All scroll types outside this region should succeed. status = host_impl_->ScrollBegin( @@ -1679,7 +1780,7 @@ TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionBasic) { host_impl_->ScrollEnd(); } -TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionWithOffset) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, NonFastScrollableRegionWithOffset) { SetupViewportLayersInnerScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); LayerImpl* outer_scroll = OuterViewportScrollLayer(); @@ -1699,6 +1800,7 @@ TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionWithOffset) { EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, status.main_thread_scrolling_reasons); + EXPECT_FALSE(status.needs_main_thread_hit_test); host_impl_->ScrollUpdate(UpdateState(gfx::Point(), gfx::Vector2d(0, 1), ui::ScrollInputType::kWheel) @@ -1711,12 +1813,19 @@ TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionWithOffset) { ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, + status.main_thread_scrolling_reasons); + EXPECT_TRUE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, + status.main_thread_scrolling_reasons); + } } -TEST_F(LayerTreeHostImplTest, ScrollHandlerNotPresent) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollHandlerNotPresent) { SetupViewportLayersInnerScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); EXPECT_FALSE(host_impl_->active_tree()->have_scroll_event_handlers()); DrawFrame(); @@ -1731,7 +1840,7 @@ TEST_F(LayerTreeHostImplTest, ScrollHandlerNotPresent) { EXPECT_FALSE(host_impl_->scroll_affects_scroll_handler()); } -TEST_F(LayerTreeHostImplTest, ScrollHandlerPresent) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollHandlerPresent) { SetupViewportLayersInnerScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); host_impl_->active_tree()->set_have_scroll_event_handlers(true); DrawFrame(); @@ -1746,7 +1855,7 @@ TEST_F(LayerTreeHostImplTest, ScrollHandlerPresent) { EXPECT_FALSE(host_impl_->scroll_affects_scroll_handler()); } -TEST_F(LayerTreeHostImplTest, ScrollUpdateReturnsCorrectValue) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollUpdateReturnsCorrectValue) { SetupViewportLayersInnerScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); DrawFrame(); @@ -1848,7 +1957,7 @@ TEST_F(LayerTreeHostImplTest, ScrollUpdateReturnsCorrectValue) { // TODO(sunyunjia): Move scroll snap tests to a separate file. // https://crbug.com/851690 -TEST_F(LayerTreeHostImplTest, ScrollSnapOnX) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollSnapOnX) { LayerImpl* overflow = CreateLayerForSnapping(); gfx::Point pointer_position(10, 10); @@ -1893,7 +2002,7 @@ TEST_F(LayerTreeHostImplTest, ScrollSnapOnX) { GetSnapContainerData(overflow)->GetTargetSnapAreaElementIds()); } -TEST_F(LayerTreeHostImplTest, ScrollSnapOnY) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollSnapOnY) { LayerImpl* overflow = CreateLayerForSnapping(); gfx::Point pointer_position(10, 10); @@ -1938,7 +2047,7 @@ TEST_F(LayerTreeHostImplTest, ScrollSnapOnY) { GetSnapContainerData(overflow)->GetTargetSnapAreaElementIds()); } -TEST_F(LayerTreeHostImplTest, ScrollSnapOnBoth) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollSnapOnBoth) { LayerImpl* overflow = CreateLayerForSnapping(); gfx::Point pointer_position(10, 10); @@ -1984,7 +2093,7 @@ TEST_F(LayerTreeHostImplTest, ScrollSnapOnBoth) { // Simulate a ScrollBegin and ScrollEnd without any intervening ScrollUpdate. // This test passes if it doesn't crash. -TEST_F(LayerTreeHostImplTest, SnapAfterEmptyScroll) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SnapAfterEmptyScroll) { CreateLayerForSnapping(); gfx::Point pointer_position(10, 10); @@ -1999,7 +2108,7 @@ TEST_F(LayerTreeHostImplTest, SnapAfterEmptyScroll) { host_impl_->ScrollEnd(true); } -TEST_F(LayerTreeHostImplTest, ScrollSnapAfterAnimatedScroll) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollSnapAfterAnimatedScroll) { LayerImpl* overflow = CreateLayerForSnapping(); gfx::Point pointer_position(10, 10); @@ -2057,7 +2166,7 @@ TEST_F(LayerTreeHostImplTest, ScrollSnapAfterAnimatedScroll) { GetSnapContainerData(overflow)->GetTargetSnapAreaElementIds()); } -TEST_F(LayerTreeHostImplTest, SnapAnimationTargetUpdated) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SnapAnimationTargetUpdated) { LayerImpl* overflow = CreateLayerForSnapping(); gfx::Point pointer_position(10, 10); @@ -2120,7 +2229,7 @@ TEST_F(LayerTreeHostImplTest, SnapAnimationTargetUpdated) { EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 50), CurrentScrollOffset(overflow)); } -TEST_F(LayerTreeHostImplTest, SnapAnimationCancelledByScroll) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SnapAnimationCancelledByScroll) { LayerImpl* overflow = CreateLayerForSnapping(); gfx::Point pointer_position(10, 10); @@ -2183,7 +2292,7 @@ TEST_F(LayerTreeHostImplTest, SnapAnimationCancelledByScroll) { GetSnapContainerData(overflow)->GetTargetSnapAreaElementIds()); } -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SnapAnimationShouldNotStartWhenScrollEndsAtSnapTarget) { LayerImpl* overflow = CreateLayerForSnapping(); @@ -2230,7 +2339,7 @@ TEST_F(LayerTreeHostImplTest, GetSnapContainerData(overflow)->GetTargetSnapAreaElementIds()); } -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, GetSnapFlingInfoAndSetAnimatingSnapTargetWhenZoomed) { LayerImpl* overflow = CreateLayerForSnapping(); // Scales the page to its 1/5. @@ -2270,7 +2379,8 @@ TEST_F(LayerTreeHostImplTest, GetSnapContainerData(overflow)->GetTargetSnapAreaElementIds()); } -TEST_F(LayerTreeHostImplTest, SnapFlingAnimationEndWithoutFinishing) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SnapFlingAnimationEndWithoutFinishing) { LayerImpl* overflow = CreateLayerForSnapping(); // Scales the page to its 1/5. host_impl_->active_tree()->PushPageScaleFromMainThread(0.2f, 0.1f, 5.f); @@ -2310,7 +2420,8 @@ TEST_F(LayerTreeHostImplTest, SnapFlingAnimationEndWithoutFinishing) { GetSnapContainerData(overflow)->GetTargetSnapAreaElementIds()); } -TEST_F(LayerTreeHostImplTest, OverscrollBehaviorPreventsPropagation) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + OverscrollBehaviorPreventsPropagation) { const gfx::Size kViewportSize(100, 100); const gfx::Size kContentSize(200, 200); SetupViewportLayersOuterScrolls(kViewportSize, kContentSize); @@ -2508,7 +2619,7 @@ TEST_F(LayerTreeHostImplTest, OverscrollBehaviorPreventsPropagation) { EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 10), CurrentScrollOffset(overflow)); } -TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) { const gfx::Size kViewportSize(100, 100); const gfx::Size kContentSize(200, 200); SetupViewportLayersOuterScrolls(kViewportSize, kContentSize); @@ -2582,7 +2693,10 @@ TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) { EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 20), CurrentScrollOffset(overflow)); } -TEST_F(LayerTreeHostImplTest, ForceMainThreadScrollWithoutScrollLayer) { +// Test that if a scroll node doesn't have an associated Layer, scrolling +// is forced to the main thread. With scroll unification, this kind of scroll +// is now handled on the impl thread but will force a repaint on each scroll. +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollNodeWithoutScrollLayer) { SetupViewportLayersInnerScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); ScrollNode* scroll_node = host_impl_->OuterViewportScrollNode(); // Change the scroll node so that it no longer has an associated layer. @@ -2595,9 +2709,20 @@ TEST_F(LayerTreeHostImplTest, ForceMainThreadScrollWithoutScrollLayer) { ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, - status.main_thread_scrolling_reasons); + + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, + status.main_thread_scrolling_reasons); + // We don't have a layer for the scroller but we didn't hit a non-fast + // scrolling region or fail hit testing the layer - we don't need a main + // thread hit test in this case. + EXPECT_FALSE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, + status.main_thread_scrolling_reasons); + } } TEST_F(CommitToPendingTreeLayerTreeHostImplTest, @@ -2712,7 +2837,8 @@ TEST_F(CommitToPendingTreeLayerTreeHostImplTest, EXPECT_FALSE(did_request_commit_); } -TEST_F(LayerTreeHostImplTest, AnimationSchedulingCommitToActiveTree) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + AnimationSchedulingCommitToActiveTree) { EXPECT_TRUE(host_impl_->CommitToActiveTree()); auto* root = SetupDefaultRootLayer(gfx::Size(50, 50)); @@ -2749,7 +2875,8 @@ TEST_F(LayerTreeHostImplTest, AnimationSchedulingCommitToActiveTree) { host_impl_ = nullptr; } -TEST_F(LayerTreeHostImplTest, AnimationSchedulingOnLayerDestruction) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + AnimationSchedulingOnLayerDestruction) { LayerImpl* root = SetupDefaultRootLayer(gfx::Size(50, 50)); LayerImpl* child = AddLayer(); @@ -2828,7 +2955,7 @@ class MissingTilesLayer : public LayerImpl { bool has_missing_tiles_; }; -TEST_F(LayerTreeHostImplTest, ImplPinchZoom) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ImplPinchZoom) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -2909,7 +3036,7 @@ TEST_F(LayerTreeHostImplTest, ImplPinchZoom) { } } -TEST_F(LayerTreeHostImplTest, ViewportScrollbarGeometry) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ViewportScrollbarGeometry) { // Tests for correct behavior of solid color scrollbars on unscrollable pages // under tricky fractional scale/size issues. @@ -2966,7 +3093,7 @@ TEST_F(LayerTreeHostImplTest, ViewportScrollbarGeometry) { EXPECT_TRUE(h_scrollbar->CanScrollOrientation()); } -TEST_F(LayerTreeHostImplTest, ViewportScrollOrder) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ViewportScrollOrder) { LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); host_impl_->active_tree()->PushPageScaleFromMainThread(1, 0.25f, 4); @@ -3036,7 +3163,8 @@ TEST_F(LayerTreeHostImplTest, ViewportScrollOrder) { // Make sure scrolls smaller than a unit applied to the viewport don't get // dropped. crbug.com/539334. -TEST_F(LayerTreeHostImplTest, ScrollViewportWithFractionalAmounts) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollViewportWithFractionalAmounts) { host_impl_->active_tree()->PushPageScaleFromMainThread(1, 1, 2); const gfx::Size content_size(1000, 1000); @@ -3093,7 +3221,7 @@ TEST_F(LayerTreeHostImplTest, ScrollViewportWithFractionalAmounts) { // Tests that scrolls during a pinch gesture (i.e. "two-finger" scrolls) work // as expected. That is, scrolling during a pinch should bubble from the inner // to the outer viewport. -TEST_F(LayerTreeHostImplTest, ScrollDuringPinchGesture) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollDuringPinchGesture) { LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); host_impl_->active_tree()->PushPageScaleFromMainThread(1, 1, 2); @@ -3153,7 +3281,7 @@ TEST_F(LayerTreeHostImplTest, ScrollDuringPinchGesture) { // Tests the "snapping" of pinch-zoom gestures to the screen edge. That is, when // a pinch zoom is anchored within a certain margin of the screen edge, we // should assume the user means to scroll into the edge of the screen. -TEST_F(LayerTreeHostImplTest, PinchZoomSnapsToScreenEdge) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, PinchZoomSnapsToScreenEdge) { LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); host_impl_->active_tree()->PushPageScaleFromMainThread(1, 1, 2); @@ -3242,7 +3370,8 @@ TEST_F(LayerTreeHostImplTest, PinchZoomSnapsToScreenEdge) { CurrentScrollOffset(InnerViewportScrollLayer())); } -TEST_F(LayerTreeHostImplTest, ImplPinchZoomWheelBubbleBetweenViewports) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ImplPinchZoomWheelBubbleBetweenViewports) { const gfx::Size content_size(200, 200); const gfx::Size viewport_size(100, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -3307,7 +3436,7 @@ TEST_F(LayerTreeHostImplTest, ImplPinchZoomWheelBubbleBetweenViewports) { CurrentScrollOffset(inner_scroll_layer)); } -TEST_F(LayerTreeHostImplTest, ScrollWithSwapPromises) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollWithSwapPromises) { ui::LatencyInfo latency_info; latency_info.set_trace_id(5); latency_info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT); @@ -3337,7 +3466,7 @@ TEST_F(LayerTreeHostImplTest, ScrollWithSwapPromises) { // Test that scrolls targeting a layer with a non-null scroll_parent() don't // bubble up. -TEST_F(LayerTreeHostImplTest, ScrollDoesntBubble) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollDoesntBubble) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); LayerImpl* viewport_scroll = InnerViewportScrollLayer(); @@ -3420,7 +3549,7 @@ TEST_F(LayerTreeHostImplTest, ScrollDoesntBubble) { } } -TEST_F(LayerTreeHostImplTest, PinchGesture) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, PinchGesture) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -3610,7 +3739,7 @@ TEST_F(LayerTreeHostImplTest, PinchGesture) { } } -TEST_F(LayerTreeHostImplTest, SyncSubpixelScrollDelta) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SyncSubpixelScrollDelta) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -3660,7 +3789,8 @@ TEST_F(LayerTreeHostImplTest, SyncSubpixelScrollDelta) { scroll_layer->ScreenSpaceTransform().To2dTranslation()); } -TEST_F(LayerTreeHostImplTest, SyncSubpixelScrollFromFractionalActiveBase) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SyncSubpixelScrollFromFractionalActiveBase) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -3699,7 +3829,8 @@ TEST_F(LayerTreeHostImplTest, SyncSubpixelScrollFromFractionalActiveBase) { gfx::Vector2dF(0, -1)); } -TEST_F(LayerTreeHostImplTest, PinchZoomTriggersPageScaleAnimation) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + PinchZoomTriggersPageScaleAnimation) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -3821,7 +3952,7 @@ TEST_F(LayerTreeHostImplTest, PinchZoomTriggersPageScaleAnimation) { } } -TEST_F(LayerTreeHostImplTest, PageScaleAnimation) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, PageScaleAnimation) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -3950,7 +4081,7 @@ TEST_F(LayerTreeHostImplTest, PageScaleAnimation) { } } -TEST_F(LayerTreeHostImplTest, PageScaleAnimationNoOp) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, PageScaleAnimationNoOp) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -4008,7 +4139,8 @@ TEST_F(LayerTreeHostImplTest, PageScaleAnimationNoOp) { } } -TEST_F(LayerTreeHostImplTest, PageScaleAnimationTransferedOnSyncTreeActivate) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + PageScaleAnimationTransferedOnSyncTreeActivate) { CreatePendingTree(); host_impl_->pending_tree()->PushPageScaleFromMainThread(1, 1, 1); SetupViewportLayers(host_impl_->pending_tree(), gfx::Size(50, 50), @@ -4132,7 +4264,8 @@ TEST_F(LayerTreeHostImplTest, PageScaleAnimationTransferedOnSyncTreeActivate) { gfx::ScrollOffset(-50, -50))); } -TEST_F(LayerTreeHostImplTest, PageScaleAnimationCompletedNotification) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + PageScaleAnimationCompletedNotification) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); DrawFrame(); @@ -4181,7 +4314,8 @@ TEST_F(LayerTreeHostImplTest, PageScaleAnimationCompletedNotification) { host_impl_->DidFinishImplFrame(begin_frame_args); } -TEST_F(LayerTreeHostImplTest, MaxScrollOffsetAffectedByViewportBoundsDelta) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + MaxScrollOffsetAffectedByViewportBoundsDelta) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); host_impl_->active_tree()->PushPageScaleFromMainThread(1, 0.5f, 4); DrawFrame(); @@ -4207,7 +4341,8 @@ TEST_F(LayerTreeHostImplTest, MaxScrollOffsetAffectedByViewportBoundsDelta) { // Ensures scroll gestures coming from scrollbars cause animations in the // appropriate scenarios. -TEST_F(LayerTreeHostImplTest, AnimatedGranularityCausesSmoothScroll) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + AnimatedGranularityCausesSmoothScroll) { gfx::Size viewport_size(300, 200); gfx::Size content_size(1000, 1000); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -4275,7 +4410,8 @@ TEST_F(LayerTreeHostImplTest, AnimatedGranularityCausesSmoothScroll) { // Ensures scroll gestures coming from scrollbars don't cause animations if // smooth scrolling is disabled. -TEST_F(LayerTreeHostImplTest, NonAnimatedGranularityCausesInstantScroll) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + NonAnimatedGranularityCausesInstantScroll) { // Disable animated scrolling LayerTreeSettings settings = DefaultSettings(); settings.enable_smooth_scroll = false; @@ -4574,7 +4710,8 @@ TEST_F(LayerTreeHostImplTestScrollbarAnimation, NoAnimator) { RunTest(LayerTreeSettings::NO_ANIMATOR); } -class LayerTreeHostImplTestScrollbarOpacity : public LayerTreeHostImplTest { +class LayerTreeHostImplTestScrollbarOpacity + : public ScrollUnifiedLayerTreeHostImplTest { protected: void RunTest(LayerTreeSettings::ScrollbarAnimator animator) { LayerTreeSettings settings = DefaultSettings(); @@ -4663,19 +4800,24 @@ class LayerTreeHostImplTestScrollbarOpacity : public LayerTreeHostImplTest { } }; -TEST_F(LayerTreeHostImplTestScrollbarOpacity, Android) { +INSTANTIATE_TEST_SUITE_P(All, + LayerTreeHostImplTestScrollbarOpacity, + testing::Bool()); + +TEST_P(LayerTreeHostImplTestScrollbarOpacity, Android) { RunTest(LayerTreeSettings::ANDROID_OVERLAY); } -TEST_F(LayerTreeHostImplTestScrollbarOpacity, AuraOverlay) { +TEST_P(LayerTreeHostImplTestScrollbarOpacity, AuraOverlay) { RunTest(LayerTreeSettings::AURA_OVERLAY); } -TEST_F(LayerTreeHostImplTestScrollbarOpacity, NoAnimator) { +TEST_P(LayerTreeHostImplTestScrollbarOpacity, NoAnimator) { RunTest(LayerTreeSettings::NO_ANIMATOR); } -class LayerTreeHostImplTestMultiScrollable : public LayerTreeHostImplTest { +class LayerTreeHostImplTestMultiScrollable + : public ScrollUnifiedLayerTreeHostImplTest { public: void SetUpLayers(LayerTreeSettings settings) { is_aura_scrollbar_ = @@ -4732,7 +4874,11 @@ class LayerTreeHostImplTestMultiScrollable : public LayerTreeHostImplTest { SolidColorScrollbarLayerImpl* scrollbar_2_; }; -TEST_F(LayerTreeHostImplTestMultiScrollable, +INSTANTIATE_TEST_SUITE_P(All, + LayerTreeHostImplTestMultiScrollable, + testing::Bool()); + +TEST_P(LayerTreeHostImplTestMultiScrollable, ScrollbarFlashAfterAnyScrollUpdate) { LayerTreeSettings settings = DefaultSettings(); settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(500); @@ -4777,7 +4923,7 @@ TEST_F(LayerTreeHostImplTestMultiScrollable, EXPECT_FALSE(animation_task_.is_null()); } -TEST_F(LayerTreeHostImplTestMultiScrollable, ScrollbarFlashWhenMouseEnter) { +TEST_P(LayerTreeHostImplTestMultiScrollable, ScrollbarFlashWhenMouseEnter) { LayerTreeSettings settings = DefaultSettings(); settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(500); settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300); @@ -4803,7 +4949,7 @@ TEST_F(LayerTreeHostImplTestMultiScrollable, ScrollbarFlashWhenMouseEnter) { EXPECT_FALSE(animation_task_.is_null()); } -TEST_F(LayerTreeHostImplTest, ScrollHitTestOnScrollbar) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollHitTestOnScrollbar) { LayerTreeSettings settings = DefaultSettings(); settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(500); settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300); @@ -4892,7 +5038,8 @@ TEST_F(LayerTreeHostImplTest, ScrollHitTestOnScrollbar) { } } -TEST_F(LayerTreeHostImplTest, ScrollbarVisibilityChangeCausesRedrawAndCommit) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollbarVisibilityChangeCausesRedrawAndCommit) { LayerTreeSettings settings = DefaultSettings(); settings.scrollbar_animator = LayerTreeSettings::AURA_OVERLAY; settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(20); @@ -4961,7 +5108,7 @@ TEST_F(LayerTreeHostImplTest, ScrollbarVisibilityChangeCausesRedrawAndCommit) { } } -TEST_F(LayerTreeHostImplTest, ScrollbarInnerLargerThanOuter) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollbarInnerLargerThanOuter) { LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -4983,7 +5130,7 @@ TEST_F(LayerTreeHostImplTest, ScrollbarInnerLargerThanOuter) { EXPECT_EQ(300, horiz_scrollbar->clip_layer_length()); } -TEST_F(LayerTreeHostImplTest, ScrollbarRegistration) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollbarRegistration) { LayerTreeSettings settings = DefaultSettings(); settings.scrollbar_animator = LayerTreeSettings::ANDROID_OVERLAY; settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(20); @@ -5077,7 +5224,7 @@ TEST_F(LayerTreeHostImplTest, ScrollbarRegistration) { root_scroll_element_id)); } -TEST_F(LayerTreeHostImplTest, ScrollBeforeMouseMove) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollBeforeMouseMove) { LayerTreeSettings settings = DefaultSettings(); settings.scrollbar_animator = LayerTreeSettings::AURA_OVERLAY; settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(20); @@ -5218,18 +5365,18 @@ void LayerTreeHostImplTest::SetupMouseMoveAtWithDeviceScale( scrollbar_animation_controller->MouseIsOverScrollbarThumb(VERTICAL)); } -TEST_F(LayerTreeHostImplTest, MouseMoveAtWithDeviceScaleOf1) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, MouseMoveAtWithDeviceScaleOf1) { SetupMouseMoveAtWithDeviceScale(1); } -TEST_F(LayerTreeHostImplTest, MouseMoveAtWithDeviceScaleOf2) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, MouseMoveAtWithDeviceScaleOf2) { SetupMouseMoveAtWithDeviceScale(2); } // This test verifies that only SurfaceLayers in the viewport and have fallbacks // that are different are included in viz::CompositorFrameMetadata's // |activation_dependencies|. -TEST_F(LayerTreeHostImplTest, ActivationDependenciesInMetadata) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ActivationDependenciesInMetadata) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); LayerImpl* root = root_layer(); @@ -5308,7 +5455,8 @@ TEST_F(LayerTreeHostImplTest, ActivationDependenciesInMetadata) { // Verify that updating the set of referenced surfaces for the active tree // causes a new CompositorFrame to be submitted, even if there is no other // damage. -TEST_F(LayerTreeHostImplTest, SurfaceReferencesChangeCausesDamage) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SurfaceReferencesChangeCausesDamage) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); auto* fake_layer_tree_frame_sink = static_cast<FakeLayerTreeFrameSink*>(host_impl_->layer_tree_frame_sink()); @@ -5340,7 +5488,7 @@ TEST_F(LayerTreeHostImplTest, SurfaceReferencesChangeCausesDamage) { } } -TEST_F(LayerTreeHostImplTest, CompositorFrameMetadata) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, CompositorFrameMetadata) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); host_impl_->active_tree()->PushPageScaleFromMainThread(1, 0.5f, 4); DrawFrame(); @@ -5467,7 +5615,8 @@ class DidDrawCheckLayer : public LayerImpl { bool did_draw_called_; }; -TEST_F(LayerTreeHostImplTest, DamageShouldNotCareAboutContributingLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + DamageShouldNotCareAboutContributingLayers) { auto* root = SetupRootLayer<DidDrawCheckLayer>(host_impl_->active_tree(), gfx::Size(10, 10)); @@ -5551,7 +5700,7 @@ TEST_F(LayerTreeHostImplTest, DamageShouldNotCareAboutContributingLayers) { } } -TEST_F(LayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) { // The root layer is always drawn, so run this test on a child layer that // will be masked out by the root layer's bounds. auto* root = SetupRootLayer<DidDrawCheckLayer>(host_impl_->active_tree(), @@ -5574,7 +5723,7 @@ TEST_F(LayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) { EXPECT_FALSE(layer->did_draw_called()); } -TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) { // The root layer is always drawn, so run this test on a child layer that // will be masked out by the root layer's bounds. auto* root = SetupRootLayer<DidDrawCheckLayer>(host_impl_->active_tree(), @@ -5613,7 +5762,7 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) { EXPECT_FALSE(layer->visible_layer_rect().IsEmpty()); } -TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) { gfx::Size big_size(1000, 1000); auto* root = SetupRootLayer<DidDrawCheckLayer>(host_impl_->active_tree(), big_size); @@ -5641,7 +5790,7 @@ TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) { EXPECT_TRUE(top_layer->did_draw_called()); } -TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, DidDrawCalledOnAllLayers) { auto* root = SetupRootLayer<DidDrawCheckLayer>(host_impl_->active_tree(), gfx::Size(10, 10)); auto* layer1 = AddLayer<DidDrawCheckLayer>(host_impl_->active_tree()); @@ -5906,11 +6055,12 @@ TEST_F(LayerTreeHostImplPrepareToDrawTest, } } -TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollRootIgnored) { SetupDefaultRootLayer(gfx::Size(10, 10)); DrawFrame(); - // Scroll event is ignored because layer is not scrollable. + // Scroll event is ignored because layer is not scrollable and there is no + // viewport. InputHandler::ScrollStatus status = host_impl_->ScrollBegin(BeginState(gfx::Point(), gfx::Vector2dF(0, 10), ui::ScrollInputType::kWheel) @@ -5923,7 +6073,7 @@ TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) { EXPECT_FALSE(did_request_commit_); } -TEST_F(LayerTreeHostImplTest, ClampingAfterActivation) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ClampingAfterActivation) { CreatePendingTree(); host_impl_->pending_tree()->PushPageScaleFromMainThread(1, 1, 1); SetupViewportLayers(host_impl_->pending_tree(), gfx::Size(50, 50), @@ -5945,7 +6095,8 @@ TEST_F(LayerTreeHostImplTest, ClampingAfterActivation) { EXPECT_EQ(CurrentScrollOffset(active_outer_layer), gfx::ScrollOffset(0, 0)); } -class LayerTreeHostImplBrowserControlsTest : public LayerTreeHostImplTest { +class LayerTreeHostImplBrowserControlsTest + : public ScrollUnifiedLayerTreeHostImplTest { public: LayerTreeHostImplBrowserControlsTest() // Make the clip size the same as the layer (content) size so the layer is @@ -6002,6 +6153,10 @@ class LayerTreeHostImplBrowserControlsTest : public LayerTreeHostImplTest { LayerTreeSettings settings_; }; // class LayerTreeHostImplBrowserControlsTest +INSTANTIATE_TEST_SUITE_P(All, + LayerTreeHostImplBrowserControlsTest, + testing::Bool()); + #define EXPECT_VIEWPORT_GEOMETRIES(expected_browser_controls_shown_ratio) \ do { \ auto* tree = host_impl_->active_tree(); \ @@ -6031,7 +6186,7 @@ class LayerTreeHostImplBrowserControlsTest : public LayerTreeHostImplTest { // size). Since the viewport got larger, the effective scrollable "content" also // did. This ensures, for one thing, that the overscroll glow is shown in the // right place. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, HidingBrowserControlsExpandsScrollableSize) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(50, 50), gfx::Size(50, 50), gfx::Size(50, 50)); @@ -6074,11 +6229,108 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, host_impl_->ScrollEnd(); } +TEST_P(LayerTreeHostImplBrowserControlsTest, + HidingBrowserControlsExpandsClipAncestorsOfReplacedOuterScroller) { + SetupBrowserControlsAndScrollLayerWithVirtualViewport( + gfx::Size(180, 180), gfx::Size(180, 180), gfx::Size(180, 180)); + + LayerTreeImpl* active_tree = host_impl_->active_tree(); + PropertyTrees* property_trees = active_tree->property_trees(); + LayerImpl* original_outer_scroll = OuterViewportScrollLayer(); + + LayerImpl* parent_clip_layer = AddLayer(); + CopyProperties(original_outer_scroll, parent_clip_layer); + parent_clip_layer->SetBounds(gfx::Size(160, 160)); + CreateClipNode(parent_clip_layer); + LayerImpl* clip_layer = AddLayer(); + clip_layer->SetBounds(gfx::Size(150, 150)); + CopyProperties(parent_clip_layer, clip_layer); + CreateClipNode(clip_layer); + LayerImpl* scroll_layer = + AddScrollableLayer(clip_layer, gfx::Size(150, 150), gfx::Size(300, 300)); + GetScrollNode(scroll_layer)->scrolls_outer_viewport = true; + ClipNode* original_outer_clip = GetClipNode(original_outer_scroll); + ClipNode* parent_clip = GetClipNode(parent_clip_layer); + ClipNode* scroll_clip = GetClipNode(clip_layer); + + auto viewport_property_ids = active_tree->ViewportPropertyIdsForTesting(); + viewport_property_ids.outer_clip = clip_layer->clip_tree_index(); + viewport_property_ids.outer_scroll = scroll_layer->scroll_tree_index(); + active_tree->SetViewportPropertyIds(viewport_property_ids); + UpdateDrawProperties(active_tree); + + EXPECT_EQ(scroll_layer, OuterViewportScrollLayer()); + EXPECT_EQ(GetScrollNode(scroll_layer), + active_tree->OuterViewportScrollNode()); + + EXPECT_EQ(1, active_tree->CurrentTopControlsShownRatio()); + EXPECT_EQ(50, host_impl_->browser_controls_manager()->ContentTopOffset()); + EXPECT_EQ(gfx::Vector2dF(), + property_trees->inner_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::Vector2dF(), + property_trees->outer_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::SizeF(300, 300), active_tree->ScrollableSize()); + EXPECT_EQ(gfx::RectF(0, 0, 180, 180), original_outer_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 160, 160), parent_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 150, 150), scroll_clip->clip); + + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, + host_impl_ + ->ScrollBegin(BeginState(gfx::Point(), gfx::Vector2dF(0, 25), + ui::ScrollInputType::kTouchscreen) + .get(), + ui::ScrollInputType::kTouchscreen) + .thread); + + // Hide the browser controls by a bit, the scrollable size should increase but + // the actual content bounds shouldn't. + host_impl_->browser_controls_manager()->ScrollBy(gfx::Vector2dF(0, 25)); + EXPECT_EQ(0.5f, active_tree->CurrentTopControlsShownRatio()); + EXPECT_EQ(25, host_impl_->browser_controls_manager()->ContentTopOffset()); + EXPECT_EQ(gfx::Vector2dF(0, 25), + property_trees->inner_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::Vector2dF(0, 25), + property_trees->outer_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::SizeF(300, 300), active_tree->ScrollableSize()); + EXPECT_EQ(gfx::RectF(0, 0, 150, 175), scroll_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 160, 175), parent_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 180, 180), original_outer_clip->clip); + + // Fully hide the browser controls. + host_impl_->browser_controls_manager()->ScrollBy(gfx::Vector2dF(0, 25)); + EXPECT_EQ(0, active_tree->CurrentTopControlsShownRatio()); + EXPECT_EQ(0, host_impl_->browser_controls_manager()->ContentTopOffset()); + EXPECT_EQ(gfx::Vector2dF(0, 50), + property_trees->inner_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::Vector2dF(0, 50), + property_trees->outer_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::SizeF(300, 300), active_tree->ScrollableSize()); + EXPECT_EQ(gfx::RectF(0, 0, 150, 200), scroll_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 160, 200), parent_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 180, 200), original_outer_clip->clip); + + // Scrolling additionally shouldn't have any effect. + host_impl_->browser_controls_manager()->ScrollBy(gfx::Vector2dF(0, 25)); + EXPECT_EQ(0, active_tree->CurrentTopControlsShownRatio()); + EXPECT_EQ(0, host_impl_->browser_controls_manager()->ContentTopOffset()); + EXPECT_EQ(gfx::Vector2dF(0, 50), + property_trees->inner_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::Vector2dF(0, 50), + property_trees->outer_viewport_container_bounds_delta()); + EXPECT_EQ(gfx::SizeF(300, 300), active_tree->ScrollableSize()); + EXPECT_EQ(gfx::RectF(0, 0, 150, 200), scroll_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 160, 200), parent_clip->clip); + EXPECT_EQ(gfx::RectF(0, 0, 180, 200), original_outer_clip->clip); + + host_impl_->browser_controls_manager()->ScrollEnd(); + host_impl_->ScrollEnd(); +} + // Ensure that moving the browser controls (i.e. omnibox/url-bar on mobile) on // pages with a non-1 minimum page scale factor (e.g. legacy desktop page) // correctly scales the clipping adjustment performed to show the newly exposed // region of the page. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, MovingBrowserControlsOuterClipDeltaScaled) { gfx::Size inner_size = gfx::Size(100, 100); gfx::Size outer_size = gfx::Size(100, 100); @@ -6122,7 +6374,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, } // Tests that browser controls affect the position of horizontal scrollbars. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, HidingBrowserControlsAdjustsScrollbarPosition) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(50, 50), gfx::Size(50, 50), gfx::Size(50, 50)); @@ -6198,7 +6450,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, host_impl_->ScrollEnd(); } -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, ScrollBrowserControlsByFractionalAmount) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(10, 10), gfx::Size(10, 10), gfx::Size(10, 10)); @@ -6231,7 +6483,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // scroll initiated on the inner viewport, causing the browser controls to show // and thus making the outer viewport scrollable, still scrolls the outer // viewport. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, BrowserControlsOuterViewportBecomesScrollable) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(10, 50), gfx::Size(10, 50), gfx::Size(10, 100)); @@ -6322,7 +6574,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // Test that the fixed position container delta is appropriately adjusted // by the browser controls showing/hiding and page scale doesn't affect it. -TEST_F(LayerTreeHostImplBrowserControlsTest, FixedContainerDelta) { +TEST_P(LayerTreeHostImplBrowserControlsTest, FixedContainerDelta) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(100, 100), gfx::Size(100, 100), gfx::Size(100, 100)); DrawFrame(); @@ -6396,7 +6648,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, FixedContainerDelta) { // Push a browser controls ratio from the main thread that we didn't send as a // delta and make sure that the ratio is clamped to the [0, 1] range. -TEST_F(LayerTreeHostImplBrowserControlsTest, BrowserControlsPushUnsentRatio) { +TEST_P(LayerTreeHostImplBrowserControlsTest, BrowserControlsPushUnsentRatio) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(10, 50), gfx::Size(10, 50), gfx::Size(10, 100)); DrawFrame(); @@ -6420,7 +6672,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, BrowserControlsPushUnsentRatio) { // Test that if a scrollable sublayer doesn't consume the scroll, // browser controls should hide when scrolling down. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, BrowserControlsScrollableSublayer) { gfx::Size sub_content_size(100, 400); gfx::Size sub_content_layer_size(100, 300); @@ -6470,7 +6722,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // Ensure setting the browser controls position explicitly using the setters on // the TreeImpl correctly affects the browser controls manager and viewport // bounds for the active tree. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, PositionBrowserControlsToActiveTreeExplicitly) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( layer_size_, layer_size_, layer_size_); @@ -6501,7 +6753,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // Ensure setting the browser controls position explicitly using the setters on // the TreeImpl correctly affects the browser controls manager and viewport // bounds for the pending tree. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, PositionBrowserControlsToPendingTreeExplicitly) { CreatePendingTree(); SetupBrowserControlsAndScrollLayerWithVirtualViewport( @@ -6546,7 +6798,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // Test that the top_controls delta and sent delta are appropriately // applied on sync tree activation. The total browser controls offset shouldn't // change after the activation. -TEST_F(LayerTreeHostImplBrowserControlsTest, ApplyDeltaOnTreeActivation) { +TEST_P(LayerTreeHostImplBrowserControlsTest, ApplyDeltaOnTreeActivation) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( layer_size_, layer_size_, layer_size_); DrawFrame(); @@ -6586,7 +6838,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, ApplyDeltaOnTreeActivation) { // the inner viewport container bounds. That is, the browser controls layout // height is the amount that the inner viewport container was shrunk outside // the compositor to accommodate the browser controls. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, BrowserControlsLayoutHeightChanged) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( layer_size_, layer_size_, layer_size_); @@ -6629,7 +6881,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // Test that showing/hiding the browser controls when the viewport is fully // scrolled doesn't incorrectly change the viewport offset due to clamping from // changing viewport bounds. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, BrowserControlsViewportOffsetClamping) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400)); @@ -6705,7 +6957,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // Test that the browser controls coming in and out maintains the same aspect // ratio between the inner and outer viewports. -TEST_F(LayerTreeHostImplBrowserControlsTest, BrowserControlsAspectRatio) { +TEST_P(LayerTreeHostImplBrowserControlsTest, BrowserControlsAspectRatio) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400)); host_impl_->active_tree()->PushPageScaleFromMainThread(1, 0.5f, 2); @@ -6745,7 +6997,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, BrowserControlsAspectRatio) { } // Test that scrolling the outer viewport affects the browser controls. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, BrowserControlsScrollOuterViewport) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400)); @@ -6821,7 +7073,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, host_impl_->ScrollEnd(); } -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, ScrollNonScrollableRootWithBrowserControls) { SetupBrowserControlsAndScrollLayerWithVirtualViewport( layer_size_, layer_size_, layer_size_); @@ -6892,7 +7144,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, // was occurring because the UpdateViewportContainerSizes was being called // before the property trees were updated with the bounds_delta. // crbug.com/597266. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, ViewportBoundsDeltaOnTreeActivation) { const gfx::Size inner_viewport_size(1000, 1000); const gfx::Size outer_viewport_size(1000, 1000); @@ -7016,7 +7268,7 @@ TEST_F(LayerTreeHostImplBrowserControlsTest, } } -TEST_F(LayerTreeHostImplTest, ScrollNonCompositedRoot) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollNonCompositedRoot) { // Test the configuration where a non-composited root layer is embedded in a // scrollable outer layer. gfx::Size surface_size(10, 10); @@ -7054,7 +7306,7 @@ TEST_F(LayerTreeHostImplTest, ScrollNonCompositedRoot) { EXPECT_TRUE(did_request_commit_); } -TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) { gfx::Size surface_size(10, 10); gfx::Size contents_size(20, 20); @@ -7083,33 +7335,35 @@ TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) { EXPECT_TRUE(did_request_commit_); } -TEST_F(LayerTreeHostImplTest, ScrollMissesChild) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollMissesChild) { gfx::Size viewport_size(5, 5); gfx::Size surface_size(10, 10); - LayerImpl* root = SetupDefaultRootLayer(surface_size); - AddScrollableLayer(root, viewport_size, surface_size); + SetupViewportLayersOuterScrolls(viewport_size, surface_size); + AddScrollableLayer(OuterViewportScrollLayer(), viewport_size, surface_size); DrawFrame(); - // Scroll event is ignored because the input coordinate is outside the layer - // boundaries. + // A scroll that doesn't hit any layers should fall back to viewport + // scrolling. InputHandler::ScrollStatus status = host_impl_->ScrollBegin( BeginState(gfx::Point(15, 5), gfx::Vector2dF(0, 10), ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer, - status.main_thread_scrolling_reasons); + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(host_impl_->CurrentlyScrollingNode(), + host_impl_->OuterViewportScrollNode()); EXPECT_FALSE(did_request_redraw_); EXPECT_FALSE(did_request_commit_); } -TEST_F(LayerTreeHostImplTest, ScrollMissesBackfacingChild) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollMissesBackfacingChild) { gfx::Size viewport_size(5, 5); gfx::Size surface_size(10, 10); - LayerImpl* root = SetupDefaultRootLayer(viewport_size); - LayerImpl* child = AddScrollableLayer(root, viewport_size, surface_size); + + SetupViewportLayersOuterScrolls(viewport_size, surface_size); + LayerImpl* child = AddScrollableLayer(OuterViewportScrollLayer(), + viewport_size, surface_size); gfx::Transform matrix; matrix.RotateAboutXAxis(180.0); @@ -7118,22 +7372,22 @@ TEST_F(LayerTreeHostImplTest, ScrollMissesBackfacingChild) { CreateEffectNode(child).double_sided = false; DrawFrame(); - // Scroll event is ignored because the scrollable layer is not facing the - // viewer and there is nothing scrollable behind it. + // The scroll shouldn't hit the child layer because the it isn't facing the + // viewer. The hit test should go through it and hit the outer viewport. InputHandler::ScrollStatus status = host_impl_->ScrollBegin( BeginState(gfx::Point(5, 5), gfx::Vector2dF(0, 10), ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer, - status.main_thread_scrolling_reasons); + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(host_impl_->CurrentlyScrollingNode(), + host_impl_->OuterViewportScrollNode()); EXPECT_FALSE(did_request_redraw_); EXPECT_FALSE(did_request_commit_); } -TEST_F(LayerTreeHostImplTest, ScrollBlockedByContentLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollLayerWithMainThreadReason) { gfx::Size scroll_container_size(5, 5); gfx::Size surface_size(10, 10); LayerImpl* root = SetupDefaultRootLayer(surface_size); @@ -7148,19 +7402,28 @@ TEST_F(LayerTreeHostImplTest, ScrollBlockedByContentLayer) { MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects; DrawFrame(); - // Scrolling fails because the content layer is asking to be scrolled on the - // main thread. InputHandler::ScrollStatus status = host_impl_->ScrollBegin( BeginState(gfx::Point(5, 5), gfx::Vector2dF(0, 10), ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + EXPECT_EQ( + MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, + host_impl_->CurrentlyScrollingNode()->main_thread_scrolling_reasons); + } else { + // Scrolling fails because the content layer is asking to be scrolled on the + // main thread. + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects, + status.main_thread_scrolling_reasons); + } } -TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnMainThread) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollRootAndChangePageScaleOnMainThread) { gfx::Size inner_viewport_size(20, 20); gfx::Size outer_viewport_size(40, 40); gfx::Size content_size(80, 80); @@ -7203,7 +7466,8 @@ TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnMainThread) { EXPECT_EQ(1, host_impl_->active_tree()->page_scale_delta()); } -TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnImplThread) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollRootAndChangePageScaleOnImplThread) { gfx::Size inner_viewport_size(20, 20); gfx::Size outer_viewport_size(40, 40); gfx::Size content_size(80, 80); @@ -7255,7 +7519,8 @@ TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnImplThread) { EXPECT_EQ(page_scale, host_impl_->active_tree()->current_page_scale_factor()); } -TEST_F(LayerTreeHostImplTest, PageScaleDeltaAppliedToRootScrollLayerOnly) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + PageScaleDeltaAppliedToRootScrollLayerOnly) { host_impl_->active_tree()->PushPageScaleFromMainThread(1, 1, 2); gfx::Size viewport_size(5, 5); gfx::Size surface_size(10, 10); @@ -7305,7 +7570,8 @@ TEST_F(LayerTreeHostImplTest, PageScaleDeltaAppliedToRootScrollLayerOnly) { outer_scroll->DrawTransform().matrix().getDouble(1, 1)); } -TEST_F(LayerTreeHostImplTest, ScrollChildAndChangePageScaleOnMainThread) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollChildAndChangePageScaleOnMainThread) { SetupViewportLayers(host_impl_->active_tree(), gfx::Size(15, 15), gfx::Size(30, 30), gfx::Size(50, 50)); LayerImpl* outer_scroll = OuterViewportScrollLayer(); @@ -7345,7 +7611,7 @@ TEST_F(LayerTreeHostImplTest, ScrollChildAndChangePageScaleOnMainThread) { EXPECT_EQ(1, host_impl_->active_tree()->page_scale_delta()); } -TEST_F(LayerTreeHostImplTest, ScrollChildBeyondLimit) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollChildBeyondLimit) { // Scroll a child layer beyond its maximum scroll range and make sure the // parent layer isn't scrolled. gfx::Size surface_size(10, 10); @@ -7490,7 +7756,7 @@ TEST_F(LayerTreeHostImplTimelinesTest, ScrollAnimatedLatchToChild) { host_impl_ = nullptr; } -TEST_F(LayerTreeHostImplTest, ScrollWithoutBubbling) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollWithoutBubbling) { // Scroll a child layer beyond its maximum scroll range and make sure the // the scroll doesn't bubble up to the parent layer. gfx::Size surface_size(20, 20); @@ -7629,7 +7895,8 @@ TEST_F(LayerTreeHostImplTest, ScrollWithoutBubbling) { // Ensure that layers who's scroll parent is the InnerViewportScrollNode are // still able to scroll on the compositor. -TEST_F(LayerTreeHostImplTest, ChildrenOfInnerScrollNodeCanScrollOnThread) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ChildrenOfInnerScrollNodeCanScrollOnThread) { gfx::Size viewport_size(10, 10); gfx::Size content_size(20, 20); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -7673,7 +7940,7 @@ TEST_F(LayerTreeHostImplTest, ChildrenOfInnerScrollNodeCanScrollOnThread) { } } -TEST_F(LayerTreeHostImplTest, ScrollEventBubbling) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollEventBubbling) { // When we try to scroll a non-scrollable child layer, the scroll delta // should be applied to one of its ancestors if possible. gfx::Size viewport_size(10, 10); @@ -7716,7 +7983,7 @@ TEST_F(LayerTreeHostImplTest, ScrollEventBubbling) { } } -TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollBeforeRedraw) { gfx::Size surface_size(10, 10); SetupViewportLayersNoScrolls(surface_size); UpdateDrawProperties(host_impl_->active_tree()); @@ -7740,7 +8007,7 @@ TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) { .thread); } -TEST_F(LayerTreeHostImplTest, ScrollAxisAlignedRotatedLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollAxisAlignedRotatedLayer) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); auto* scroll_layer = InnerViewportScrollLayer(); scroll_layer->SetDrawsContent(true); @@ -7798,7 +8065,7 @@ TEST_F(LayerTreeHostImplTest, ScrollAxisAlignedRotatedLayer) { wheel_scroll_delta)); } -TEST_F(LayerTreeHostImplTest, ScrollNonAxisAlignedRotatedLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollNonAxisAlignedRotatedLayer) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); auto* scroll_layer = InnerViewportScrollLayer(); float child_layer_angle = -20; @@ -7891,7 +8158,7 @@ TEST_F(LayerTreeHostImplTest, ScrollNonAxisAlignedRotatedLayer) { } } -TEST_F(LayerTreeHostImplTest, ScrollPerspectiveTransformedLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollPerspectiveTransformedLayer) { // When scrolling an element with perspective, the distance scrolled // depends on the point at which the scroll begins. SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); @@ -7973,7 +8240,7 @@ TEST_F(LayerTreeHostImplTest, ScrollPerspectiveTransformedLayer) { } } -TEST_F(LayerTreeHostImplTest, ScrollScaledLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollScaledLayer) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); auto* scroll_layer = InnerViewportScrollLayer(); @@ -8032,7 +8299,7 @@ TEST_F(LayerTreeHostImplTest, ScrollScaledLayer) { wheel_scroll_delta)); } -TEST_F(LayerTreeHostImplTest, ScrollViewportRounding) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollViewportRounding) { int width = 332; int height = 20; int scale = 3; @@ -8048,7 +8315,7 @@ TEST_F(LayerTreeHostImplTest, ScrollViewportRounding) { MaxScrollOffset(inner_viewport_scroll_layer)); } -TEST_F(LayerTreeHostImplTest, RootLayerScrollOffsetDelegation) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RootLayerScrollOffsetDelegation) { TestInputHandlerClient scroll_watcher; SetupViewportLayersInnerScrolls(gfx::Size(10, 20), gfx::Size(100, 100)); auto* scroll_layer = InnerViewportScrollLayer(); @@ -8166,7 +8433,7 @@ void CheckLayerScrollDelta(LayerImpl* layer, gfx::Vector2dF scroll_delta) { EXPECT_EQ(expected_point.ToString(), translated_point.ToString()); } -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ExternalRootLayerScrollOffsetDelegationReflectedInNextDraw) { SetupViewportLayersInnerScrolls(gfx::Size(10, 20), gfx::Size(100, 100)); auto* scroll_layer = InnerViewportScrollLayer(); @@ -8201,7 +8468,7 @@ TEST_F(LayerTreeHostImplTest, // Ensure the viewport correctly handles the user_scrollable bits. That is, if // the outer viewport disables user scrolling, we should still be able to // scroll the inner viewport. -TEST_F(LayerTreeHostImplTest, ViewportUserScrollable) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ViewportUserScrollable) { gfx::Size viewport_size(100, 100); gfx::Size content_size(200, 200); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -8367,7 +8634,7 @@ TEST_F(LayerTreeHostImplTest, ViewportUserScrollable) { // Ensure that the SetSynchronousInputHandlerRootScrollOffset method used by // the WebView API correctly respects the user_scrollable bits on both of the // inner and outer viewport scroll nodes. -TEST_F(LayerTreeHostImplTest, SetRootScrollOffsetUserScrollable) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SetRootScrollOffsetUserScrollable) { gfx::Size viewport_size(100, 100); gfx::Size content_size(200, 200); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -8480,14 +8747,14 @@ TEST_F(LayerTreeHostImplTest, SetRootScrollOffsetUserScrollable) { // The SetSynchronousInputHandlerRootScrollOffset API can be called while there // is no inner viewport set. This test passes if we don't crash. -TEST_F(LayerTreeHostImplTest, SetRootScrollOffsetNoViewportCrash) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SetRootScrollOffsetNoViewportCrash) { auto* inner_scroll = InnerViewportScrollLayer(); ASSERT_FALSE(inner_scroll); gfx::ScrollOffset scroll_offset(25, 30); host_impl_->SetSynchronousInputHandlerRootScrollOffset(scroll_offset); } -TEST_F(LayerTreeHostImplTest, OverscrollRoot) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OverscrollRoot) { InputHandlerScrollResult scroll_result; SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); @@ -8641,7 +8908,7 @@ TEST_F(LayerTreeHostImplTest, OverscrollRoot) { host_impl_->ScrollEnd(); } -TEST_F(LayerTreeHostImplTest, OverscrollChildWithoutBubbling) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OverscrollChildWithoutBubbling) { // Scroll child layers beyond their maximum scroll range and make sure root // overscroll does not accumulate. InputHandlerScrollResult scroll_result; @@ -8746,7 +9013,7 @@ TEST_F(LayerTreeHostImplTest, OverscrollChildWithoutBubbling) { } } -TEST_F(LayerTreeHostImplTest, OverscrollChildEventBubbling) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OverscrollChildEventBubbling) { // When we try to scroll a non-scrollable child layer, the scroll delta // should be applied to one of its ancestors if possible. Overscroll should // be reflected only when it has bubbled up to the root scrolling layer. @@ -8784,7 +9051,7 @@ TEST_F(LayerTreeHostImplTest, OverscrollChildEventBubbling) { } } -TEST_F(LayerTreeHostImplTest, OverscrollAlways) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OverscrollAlways) { InputHandlerScrollResult scroll_result; LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -8813,7 +9080,7 @@ TEST_F(LayerTreeHostImplTest, OverscrollAlways) { EXPECT_EQ(gfx::Vector2dF(0, 10), host_impl_->accumulated_root_overscroll()); } -TEST_F(LayerTreeHostImplTest, NoOverscrollWhenNotAtEdge) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, NoOverscrollWhenNotAtEdge) { InputHandlerScrollResult scroll_result; gfx::Size viewport_size(100, 100); gfx::Size content_size(200, 200); @@ -8898,7 +9165,7 @@ TEST_F(LayerTreeHostImplTest, NoOverscrollWhenNotAtEdge) { } } -TEST_F(LayerTreeHostImplTest, NoOverscrollOnNonViewportLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, NoOverscrollOnNonViewportLayers) { const gfx::Size content_size(200, 200); const gfx::Size viewport_size(100, 100); @@ -8963,7 +9230,15 @@ TEST_F(LayerTreeHostImplTest, NoOverscrollOnNonViewportLayers) { host_impl_->ScrollEnd(); } -TEST_F(LayerTreeHostImplTest, OverscrollOnMainThread) { +// This ensures that the --disable-threaded-scrolling flag is respected even +// when a scroll occurs outside of a layer which normally falls back to the +// inner viewport layer. https://crbug.com/625100. +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OverscrollOnMainThread) { + // TODO(bokan): The meaning of this flag is lost with scroll unification. We + // need to decide what we should do with it. https://crbug.com/1086625. + if (base::FeatureList::IsEnabled(features::kScrollUnification)) + return; + InputHandlerScrollResult scroll_result; LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -9005,7 +9280,7 @@ TEST_F(LayerTreeHostImplTest, OverscrollOnMainThread) { // Test that scrolling the inner viewport directly works, as can happen when the // scroll chains up to it from an sibling of the outer viewport. -TEST_F(LayerTreeHostImplTest, ScrollFromOuterViewportSibling) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollFromOuterViewportSibling) { const gfx::Size viewport_size(100, 100); SetupViewportLayersNoScrolls(viewport_size); @@ -9081,7 +9356,8 @@ TEST_F(LayerTreeHostImplTest, ScrollFromOuterViewportSibling) { // Test that scrolls chain correctly when a child scroller on the page (e.g. a // scrolling div) is set as the outer viewport. This happens in the // rootScroller proposal. -TEST_F(LayerTreeHostImplTest, ScrollChainingWithReplacedOuterViewport) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollChainingWithReplacedOuterViewport) { const gfx::Size content_size(200, 200); const gfx::Size viewport_size(100, 100); @@ -9211,7 +9487,7 @@ TEST_F(LayerTreeHostImplTest, ScrollChainingWithReplacedOuterViewport) { // scrolling div) is set as the outer viewport but scrolls start from a layer // that's not a descendant of the outer viewport. This happens in the // rootScroller proposal. -TEST_F(LayerTreeHostImplTest, RootScrollerScrollNonDescendant) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RootScrollerScrollNonDescendant) { const gfx::Size content_size(300, 300); const gfx::Size viewport_size(300, 300); @@ -9381,7 +9657,7 @@ TEST_F(LayerTreeHostImplTest, RootScrollerScrollNonDescendant) { } } -TEST_F(LayerTreeHostImplTest, OverscrollOnImplThread) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OverscrollOnImplThread) { InputHandlerScrollResult scroll_result; LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -9514,7 +9790,7 @@ class BlendStateCheckLayer : public LayerImpl { viz::ResourceId resource_id_; }; -TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) { LayerImpl* root = SetupDefaultRootLayer(gfx::Size(10, 10)); root->SetDrawsContent(false); @@ -9710,7 +9986,7 @@ static bool MayContainVideoBitSetOnFrameData(LayerTreeHostImpl* host_impl) { return frame.may_contain_video; } -TEST_F(LayerTreeHostImplTest, MayContainVideo) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, MayContainVideo) { gfx::Size big_size(1000, 1000); auto* root = SetupRootLayer<DidDrawCheckLayer>(host_impl_->active_tree(), big_size); @@ -10020,7 +10296,7 @@ class FakeDrawableLayerImpl : public LayerImpl { // Make sure damage tracking propagates all the way to the viz::CompositorFrame // submitted to the LayerTreeFrameSink, where it should request to swap only // the sub-buffer that is damaged. -TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, PartialSwapReceivesDamageRect) { auto gl_owned = std::make_unique<viz::TestGLES2Interface>(); gl_owned->set_have_post_sub_buffer(true); scoped_refptr<viz::TestContextProvider> context_provider( @@ -10108,7 +10384,7 @@ TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) { layer_tree_host_impl->ReleaseLayerTreeFrameSink(); } -TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) { LayerImpl* root = SetupDefaultRootLayer(gfx::Size(10, 10)); LayerImpl* child = AddLayer(); child->SetBounds(gfx::Size(10, 10)); @@ -10153,7 +10429,7 @@ class FakeLayerWithQuads : public LayerImpl { : LayerImpl(tree_impl, id) {} }; -TEST_F(LayerTreeHostImplTest, LayersFreeTextures) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, LayersFreeTextures) { scoped_refptr<viz::TestContextProvider> context_provider = viz::TestContextProvider::Create(); viz::TestSharedImageInterface* sii = context_provider->SharedImageInterface(); @@ -10187,7 +10463,7 @@ TEST_F(LayerTreeHostImplTest, LayersFreeTextures) { EXPECT_EQ(0u, sii->shared_image_count()); } -TEST_F(LayerTreeHostImplTest, HasTransparentBackground) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, HasTransparentBackground) { SetupDefaultRootLayer(gfx::Size(10, 10)); host_impl_->active_tree()->set_background_color(SK_ColorWHITE); UpdateDrawProperties(host_impl_->active_tree()); @@ -10332,7 +10608,7 @@ class GLRendererWithSetupQuadForAntialiasing : public viz::GLRenderer { using viz::GLRenderer::ShouldAntialiasQuad; }; -TEST_F(LayerTreeHostImplTest, FarAwayQuadsDontNeedAA) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, FarAwayQuadsDontNeedAA) { // Due to precision issues (especially on Android), sometimes far // away quads can end up thinking they need AA. float device_scale_factor = 4 / 3; @@ -10433,7 +10709,7 @@ class CountingSoftwareDevice : public viz::SoftwareOutputDevice { int frames_began_, frames_ended_; }; -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ForcedDrawToSoftwareDeviceSkipsUnsupportedLayers) { set_reduce_memory_result(false); EXPECT_TRUE(CreateHostImpl(DefaultSettings(), @@ -10468,7 +10744,7 @@ TEST_F(LayerTreeHostImplTest, } // Checks that we use the memory limits provided. -TEST_F(LayerTreeHostImplTest, MemoryLimits) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, MemoryLimits) { host_impl_->ReleaseLayerTreeFrameSink(); host_impl_ = nullptr; @@ -10628,7 +10904,7 @@ TEST_F(LayerTreeHostImplTestPrepareTiles, PrepareTilesWhenInvisible) { EXPECT_TRUE(fake_host_impl_->prepare_tiles_needed()); } -TEST_F(LayerTreeHostImplTest, UIResourceManagement) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, UIResourceManagement) { auto test_context_provider = viz::TestContextProvider::Create(); viz::TestSharedImageInterface* sii = test_context_provider->SharedImageInterface(); @@ -10671,7 +10947,7 @@ TEST_F(LayerTreeHostImplTest, UIResourceManagement) { EXPECT_EQ(0u, sii->shared_image_count()); } -TEST_F(LayerTreeHostImplTest, CreateETC1UIResource) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, CreateETC1UIResource) { auto test_context_provider = viz::TestContextProvider::Create(); viz::TestSharedImageInterface* sii = test_context_provider->SharedImageInterface(); @@ -10696,7 +10972,7 @@ TEST_F(LayerTreeHostImplTest, CreateETC1UIResource) { EXPECT_NE(0u, id1); } -TEST_F(LayerTreeHostImplTest, ObeyMSAACaps) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ObeyMSAACaps) { LayerTreeSettings msaaSettings = DefaultSettings(); msaaSettings.gpu_rasterization_msaa_sample_count = 4; @@ -10806,22 +11082,27 @@ TEST_P(LayerTreeHostImplTestWithRenderer, ShutdownReleasesContext) { LayerImpl* root = SetupDefaultRootLayer(gfx::Size(10, 10)); struct Helper { std::unique_ptr<viz::CopyOutputResult> unprocessed_result; - void OnResult(std::unique_ptr<viz::CopyOutputResult> result) { + void OnResult(base::OnceClosure finished, + std::unique_ptr<viz::CopyOutputResult> result) { unprocessed_result = std::move(result); + std::move(finished).Run(); } } helper; GetEffectNode(root)->has_copy_request = true; + base::RunLoop copy_request_run_loop; GetPropertyTrees(root)->effect_tree.AddCopyRequest( root->effect_tree_index(), std::make_unique<viz::CopyOutputRequest>( viz::CopyOutputRequest::ResultFormat::RGBA_TEXTURE, - base::BindOnce(&Helper::OnResult, base::Unretained(&helper)))); + base::BindOnce(&Helper::OnResult, base::Unretained(&helper), + copy_request_run_loop.QuitClosure()))); DrawFrame(); auto* sii = context_provider->SharedImageInterface(); // The CopyOutputResult has a ref on the viz::ContextProvider and a shared // image allocated. + copy_request_run_loop.Run(); EXPECT_TRUE(helper.unprocessed_result); EXPECT_FALSE(context_provider->HasOneRef()); EXPECT_EQ(1u, sii->shared_image_count()); @@ -10839,12 +11120,15 @@ TEST_P(LayerTreeHostImplTestWithRenderer, ShutdownReleasesContext) { helper.unprocessed_result.reset(); } -TEST_F(LayerTreeHostImplTest, ScrollUnknownNotOnAncestorChain) { +// This tests the case where hit testing only on scrollable layers returns a +// layer that's outside the scroll chain of the first hit test *any* layer. See +// LayerTreeHostImpl::IsInitialScrollHitTestReliable for details. +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollHitTestIsNotReliable) { // If we ray cast a scroller that is not on the first layer's ancestor chain, // we should return SCROLL_UNKNOWN. gfx::Size viewport_size(50, 50); gfx::Size content_size(100, 100); - SetupViewportLayersInnerScrolls(viewport_size, content_size); + SetupViewportLayersOuterScrolls(viewport_size, content_size); LayerImpl* occluder_layer = AddLayer(); occluder_layer->SetDrawsContent(true); @@ -10863,20 +11147,27 @@ TEST_F(LayerTreeHostImplTest, ScrollUnknownNotOnAncestorChain) { ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_TRUE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest, + status.main_thread_scrolling_reasons); + } } -TEST_F(LayerTreeHostImplTest, ScrollUnknownScrollAncestorMismatch) { +// Similar but different case to above. See +// LayerTreeHostImpl::IsInitialScrollHitTestReliable for details. +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollHitTestAncestorMismatch) { // If we ray cast a scroller this is on the first layer's ancestor chain, but // is not the first scroller we encounter when walking up from the layer, we // should also return SCROLL_UNKNOWN. gfx::Size viewport_size(50, 50); gfx::Size content_size(100, 100); - SetupViewportLayersInnerScrolls(viewport_size, content_size); + SetupViewportLayersOuterScrolls(viewport_size, content_size); - LayerImpl* scroll_layer = InnerViewportScrollLayer(); + LayerImpl* scroll_layer = OuterViewportScrollLayer(); LayerImpl* child_scroll_clip = AddLayer(); CopyProperties(scroll_layer, child_scroll_clip); @@ -10899,12 +11190,17 @@ TEST_F(LayerTreeHostImplTest, ScrollUnknownScrollAncestorMismatch) { ui::ScrollInputType::kWheel) .get(), ui::ScrollInputType::kWheel); - EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest, - status.main_thread_scrolling_reasons); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_TRUE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest, + status.main_thread_scrolling_reasons); + } } -TEST_F(LayerTreeHostImplTest, ScrollInvisibleScroller) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollInvisibleScroller) { gfx::Size viewport_size(50, 50); gfx::Size content_size(100, 100); SetupViewportLayersInnerScrolls(viewport_size, content_size); @@ -10932,7 +11228,8 @@ TEST_F(LayerTreeHostImplTest, ScrollInvisibleScroller) { // Make sure LatencyInfo carried by LatencyInfoSwapPromise are passed // in viz::CompositorFrameMetadata. -TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + LatencyInfoPassedToCompositorFrameMetadata) { LayerTreeSettings settings = DefaultSettings(); settings.commit_to_active_tree = false; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -10962,7 +11259,8 @@ TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) { } #if defined(OS_ANDROID) -TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SelectionBoundsPassedToCompositorFrameMetadata) { LayerImpl* root = SetupRootLayer<SolidColorLayerImpl>( host_impl_->active_tree(), gfx::Size(10, 10)); UpdateDrawProperties(host_impl_->active_tree()); @@ -10992,7 +11290,7 @@ TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) { EXPECT_TRUE(selection_after.end.visible()); } -TEST_F(LayerTreeHostImplTest, HiddenSelectionBoundsStayHidden) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, HiddenSelectionBoundsStayHidden) { LayerImpl* root = SetupDefaultRootLayer(gfx::Size(10, 10)); UpdateDrawProperties(host_impl_->active_tree()); @@ -11051,7 +11349,7 @@ class SimpleSwapPromiseMonitor : public SwapPromiseMonitor { int* set_needs_redraw_count_; }; -TEST_F(LayerTreeHostImplTest, SimpleSwapPromiseMonitor) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SimpleSwapPromiseMonitor) { int set_needs_commit_count = 0; int set_needs_redraw_count = 0; @@ -11622,7 +11920,7 @@ TEST_F(LayerTreeHostImplWithBrowserControlsTest, // Tests that when we set a child scroller (e.g. a scrolling div) as the outer // viewport, scrolling it controls the browser controls. -TEST_F(LayerTreeHostImplBrowserControlsTest, +TEST_P(LayerTreeHostImplBrowserControlsTest, ReplacedOuterViewportScrollsBrowserControls) { const gfx::Size scroll_content_size(400, 400); const gfx::Size root_layer_size(200, 200); @@ -11859,7 +12157,8 @@ TEST_F(LayerTreeHostImplWithImplicitLimitsTest, ImplicitMemoryLimits) { 150u * 1024u * 1024u); } -TEST_F(LayerTreeHostImplTest, ExternalTransformReflectedInNextDraw) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ExternalTransformReflectedInNextDraw) { const gfx::Size viewport_size(50, 50); const gfx::Size layer_size(100, 100); gfx::Transform external_transform; @@ -11885,7 +12184,7 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformReflectedInNextDraw) { external_transform, layer->draw_properties().target_space_transform); } -TEST_F(LayerTreeHostImplTest, ExternalTransformSetNeedsRedraw) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ExternalTransformSetNeedsRedraw) { const gfx::Size viewport_size(100, 100); SetupDefaultRootLayer(viewport_size); UpdateDrawProperties(host_impl_->active_tree()); @@ -11914,7 +12213,7 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformSetNeedsRedraw) { EXPECT_FALSE(last_on_draw_frame_->has_no_damage); } -TEST_F(LayerTreeHostImplTest, OnMemoryPressure) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OnMemoryPressure) { gfx::Size size(200, 200); viz::ResourceFormat format = viz::RGBA_8888; gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); @@ -11936,7 +12235,7 @@ TEST_F(LayerTreeHostImplTest, OnMemoryPressure) { EXPECT_LT(memory_usage_after_memory_pressure, current_memory_usage); } -TEST_F(LayerTreeHostImplTest, OnDrawConstraintSetNeedsRedraw) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OnDrawConstraintSetNeedsRedraw) { const gfx::Size viewport_size(100, 100); SetupDefaultRootLayer(viewport_size); UpdateDrawProperties(host_impl_->active_tree()); @@ -11969,7 +12268,7 @@ TEST_F(LayerTreeHostImplTest, OnDrawConstraintSetNeedsRedraw) { // This test verifies that the viewport damage rect is the full viewport and not // just part of the viewport in the presence of an external viewport. -TEST_F(LayerTreeHostImplTest, FullViewportDamageAfterOnDraw) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, FullViewportDamageAfterOnDraw) { const gfx::Size viewport_size(100, 100); SetupDefaultRootLayer(viewport_size); UpdateDrawProperties(host_impl_->active_tree()); @@ -12089,7 +12388,8 @@ TEST_F(CommitToPendingTreeLayerTreeHostImplTest, EXPECT_TRUE(host_impl_->active_tree()->needs_update_draw_properties()); } -TEST_F(LayerTreeHostImplTest, ExternalViewportAffectsVisibleRects) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ExternalViewportAffectsVisibleRects) { const gfx::Size viewport_size(50, 50); const gfx::Size layer_size(100, 100); SetupViewportLayersInnerScrolls(viewport_size, layer_size); @@ -12118,7 +12418,8 @@ TEST_F(LayerTreeHostImplTest, ExternalViewportAffectsVisibleRects) { EXPECT_EQ(gfx::Rect(90, 90), content_layer->visible_layer_rect()); } -TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsVisibleRects) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ExternalTransformAffectsVisibleRects) { const gfx::Size viewport_size(50, 50); const gfx::Size layer_size(100, 100); SetupViewportLayersInnerScrolls(viewport_size, layer_size); @@ -12152,7 +12453,8 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsVisibleRects) { EXPECT_EQ(gfx::Rect(50, 50), content_layer->visible_layer_rect()); } -TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ExternalTransformAffectsSublayerScaleFactor) { const gfx::Size viewport_size(50, 50); const gfx::Size layer_size(100, 100); SetupViewportLayersInnerScrolls(viewport_size, layer_size); @@ -12196,7 +12498,7 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) { #if defined(OS_MACOSX) // Ensure Mac wheel scrolling causes instant scrolling. This test can be removed // once https://crbug.com/574283 is fixed. -TEST_F(LayerTreeHostImplTest, MacWheelIsNonAnimated) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, MacWheelIsNonAnimated) { const gfx::Size content_size(1000, 1000); const gfx::Size viewport_size(50, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -12219,7 +12521,116 @@ TEST_F(LayerTreeHostImplTest, MacWheelIsNonAnimated) { } #endif -TEST_F(LayerTreeHostImplTest, ScrollAnimated) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OneScrollForFirstScrollDelay) { + LayerTreeSettings settings = DefaultSettings(); + settings.commit_to_active_tree = false; + CreateHostImpl(settings, CreateLayerTreeFrameSink()); + SetupRootLayer<SolidColorLayerImpl>(host_impl_->active_tree(), + gfx::Size(10, 10)); + UpdateDrawProperties(host_impl_->active_tree()); + EXPECT_EQ(first_scroll_observed, 0); + + // LatencyInfo for the first scroll. + ui::LatencyInfo latency_info; + latency_info.set_trace_id(5); + latency_info.AddLatencyNumber( + ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT); + std::unique_ptr<SwapPromise> swap_promise( + new LatencyInfoSwapPromise(latency_info)); + host_impl_->active_tree()->QueuePinnedSwapPromise(std::move(swap_promise)); + + host_impl_->SetFullViewportDamage(); + host_impl_->SetNeedsRedraw(); + DrawFrame(); + + constexpr uint32_t frame_token_1 = 1; + viz::FrameTimingDetails mock_details; + mock_details.presentation_feedback = ExampleFeedback(); + // When the LayerTreeHostImpl receives presentation feedback, the callback + // will be fired. + host_impl_->DidPresentCompositorFrame(frame_token_1, mock_details); + + EXPECT_EQ(first_scroll_observed, 1); +} + +TEST_P(ScrollUnifiedLayerTreeHostImplTest, OtherInputsForFirstScrollDelay) { + LayerTreeSettings settings = DefaultSettings(); + settings.commit_to_active_tree = false; + CreateHostImpl(settings, CreateLayerTreeFrameSink()); + SetupRootLayer<SolidColorLayerImpl>(host_impl_->active_tree(), + gfx::Size(10, 10)); + UpdateDrawProperties(host_impl_->active_tree()); + EXPECT_EQ(first_scroll_observed, 0); + + // LatencyInfo for the first input, which is not scroll. + ui::LatencyInfo latency_info; + latency_info.set_trace_id(5); + latency_info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT); + std::unique_ptr<SwapPromise> swap_promise( + new LatencyInfoSwapPromise(latency_info)); + host_impl_->active_tree()->QueuePinnedSwapPromise(std::move(swap_promise)); + + host_impl_->SetFullViewportDamage(); + host_impl_->SetNeedsRedraw(); + DrawFrame(); + + constexpr uint32_t frame_token_1 = 1; + viz::FrameTimingDetails mock_details; + mock_details.presentation_feedback = ExampleFeedback(); + // When the LayerTreeHostImpl receives presentation feedback, the callback + // will be fired. + host_impl_->DidPresentCompositorFrame(frame_token_1, mock_details); + + EXPECT_EQ(first_scroll_observed, 0); +} + +TEST_P(ScrollUnifiedLayerTreeHostImplTest, MultipleScrollsForFirstScrollDelay) { + LayerTreeSettings settings = DefaultSettings(); + settings.commit_to_active_tree = false; + CreateHostImpl(settings, CreateLayerTreeFrameSink()); + SetupRootLayer<SolidColorLayerImpl>(host_impl_->active_tree(), + gfx::Size(10, 10)); + UpdateDrawProperties(host_impl_->active_tree()); + EXPECT_EQ(first_scroll_observed, 0); + + // LatencyInfo for the first scroll. + ui::LatencyInfo latency_info; + latency_info.set_trace_id(5); + latency_info.AddLatencyNumber( + ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT); + std::unique_ptr<SwapPromise> swap_promise( + new LatencyInfoSwapPromise(latency_info)); + host_impl_->active_tree()->QueuePinnedSwapPromise(std::move(swap_promise)); + DrawFrame(); + constexpr uint32_t frame_token_1 = 1; + viz::FrameTimingDetails mock_details; + mock_details.presentation_feedback = ExampleFeedback(); + // When the LayerTreeHostImpl receives presentation feedback, the callback + // will be fired. + host_impl_->DidPresentCompositorFrame(frame_token_1, mock_details); + EXPECT_EQ(first_scroll_observed, 1); + + // LatencyInfo for the second scroll. + ui::LatencyInfo latency_info2; + latency_info2.set_trace_id(6); + latency_info2.AddLatencyNumber( + ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT); + std::unique_ptr<SwapPromise> swap_promise2( + new LatencyInfoSwapPromise(latency_info2)); + host_impl_->active_tree()->QueuePinnedSwapPromise(std::move(swap_promise2)); + host_impl_->SetFullViewportDamage(); + host_impl_->SetNeedsRedraw(); + DrawFrame(); + constexpr uint32_t frame_token_2 = 2; + viz::FrameTimingDetails mock_details2; + mock_details2.presentation_feedback = ExampleFeedback(); + // When the LayerTreeHostImpl receives presentation feedback, the callback + // will be fired. + host_impl_->DidPresentCompositorFrame(frame_token_2, mock_details2); + EXPECT_EQ(first_scroll_observed, 1); +} + +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollAnimated) { const gfx::Size content_size(1000, 1000); const gfx::Size viewport_size(50, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -12327,7 +12738,7 @@ TEST_F(LayerTreeHostImplTest, ScrollAnimated) { // Tests latching behavior, in particular when a ScrollEnd is received but a // new ScrollBegin is received before the animation from the previous gesture // stream is finished. -TEST_F(LayerTreeHostImplTest, ScrollAnimatedLatching) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollAnimatedLatching) { const gfx::Size content_size(1000, 1000); const gfx::Size viewport_size(50, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -12426,7 +12837,7 @@ TEST_F(LayerTreeHostImplTest, ScrollAnimatedLatching) { // factor. That is, if you zoom into the page, a wheel scroll should scroll the // content *less* than before so that it appears to move the same distance when // zoomed in. -TEST_F(LayerTreeHostImplTest, ScrollAnimatedWhileZoomed) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollAnimatedWhileZoomed) { const gfx::Size content_size(1000, 1000); const gfx::Size viewport_size(50, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -12503,7 +12914,7 @@ TEST_F(LayerTreeHostImplTest, ScrollAnimatedWhileZoomed) { // inner viewport is animating. Specifically this test makes sure the animation // update doesn't get confused between the currently scrolling node and the // currently animating node which are different. See https://crbug.com/1070561. -TEST_F(LayerTreeHostImplTest, ScrollAnimatedUpdateInnerViewport) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollAnimatedUpdateInnerViewport) { const gfx::Size content_size(210, 1000); const gfx::Size viewport_size(200, 200); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -12602,7 +13013,8 @@ TEST_F(LayerTreeHostImplTest, ScrollAnimatedUpdateInnerViewport) { } // This tests that faded-out Aura scrollbars can't be interacted with. -TEST_F(LayerTreeHostImplTest, FadedOutPaintedOverlayScrollbarHitTest) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + FadedOutPaintedOverlayScrollbarHitTest) { LayerTreeSettings settings = DefaultSettings(); settings.compositor_threaded_scrollbar_scrolling = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -12645,7 +13057,7 @@ TEST_F(LayerTreeHostImplTest, FadedOutPaintedOverlayScrollbarHitTest) { auto& scrollbar_effect_node = CreateEffectNode(scrollbar); scrollbar_effect_node.opacity = 0.8; - host_impl_->MouseDown(gfx::PointF(350, 18), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 18), /*jump_key_modifier*/ false); InputHandlerPointerResult result = host_impl_->MouseMoveAt(gfx::Point(350, 28)); EXPECT_GT(result.scroll_offset.y(), 0u); @@ -12654,7 +13066,7 @@ TEST_F(LayerTreeHostImplTest, FadedOutPaintedOverlayScrollbarHitTest) { // Scrolling shouldn't occur at opacity = 0. scrollbar_effect_node.opacity = 0; - host_impl_->MouseDown(gfx::PointF(350, 18), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 18), /*jump_key_modifier*/ false); result = host_impl_->MouseMoveAt(gfx::Point(350, 28)); EXPECT_EQ(result.scroll_offset.y(), 0u); host_impl_->MouseUp(gfx::PointF(350, 28)); @@ -12664,11 +13076,73 @@ TEST_F(LayerTreeHostImplTest, FadedOutPaintedOverlayScrollbarHitTest) { host_impl_ = nullptr; } +// Tests that deleting a horizontal scrollbar doesn't affect the autoscroll task +// for the vertical scrollbar. +TEST_P(ScrollUnifiedLayerTreeHostImplTest, AutoscrollOnDeletedScrollbar) { + LayerTreeSettings settings = DefaultSettings(); + settings.compositor_threaded_scrollbar_scrolling = true; + CreateHostImpl(settings, CreateLayerTreeFrameSink()); + + // Setup the viewport. + const gfx::Size viewport_size = gfx::Size(360, 600); + const gfx::Size content_size = gfx::Size(345, 3800); + SetupViewportLayersOuterScrolls(viewport_size, content_size); + LayerImpl* scroll_layer = OuterViewportScrollLayer(); + + // Set up the scrollbar and its dimensions. + LayerTreeImpl* layer_tree_impl = host_impl_->active_tree(); + auto* scrollbar = AddLayer<PaintedScrollbarLayerImpl>( + layer_tree_impl, ScrollbarOrientation::VERTICAL, false, true); + SetupScrollbarLayerCommon(scroll_layer, scrollbar); + scrollbar->SetHitTestable(true); + + const gfx::Size scrollbar_size = gfx::Size(15, 600); + scrollbar->SetBounds(scrollbar_size); + + // Set up the thumb dimensions. + scrollbar->SetThumbThickness(15); + scrollbar->SetThumbLength(50); + scrollbar->SetTrackRect(gfx::Rect(0, 15, 15, 575)); + scrollbar->SetOffsetToTransformParent(gfx::Vector2dF(345, 0)); + + TestInputHandlerClient input_handler_client; + host_impl_->BindToClient(&input_handler_client); + + // PointerDown on the scrollbar schedules an autoscroll task. + host_impl_->MouseDown(gfx::PointF(350, 580), /*jump_key_modifier*/ false); + EXPECT_TRUE(!host_impl_->CurrentlyScrollingNode()); + + // Now, unregister the horizontal scrollbar and test that the autoscroll task + // that was scheduled for the vertical scrollbar still exists. (Note that + // adding a horizontal scrollbar layer is not needed. This test merely checks + // the logic inside ScrollbarController::DidUnregisterScrollbar) + host_impl_->DidUnregisterScrollbarLayer(scroll_layer->element_id(), + ScrollbarOrientation::HORIZONTAL); + EXPECT_TRUE(host_impl_->scrollbar_controller_for_testing() + ->AutoscrollTaskIsScheduled()); + + // If a call comes in to delete the scrollbar layer for which the autoscroll + // was scheduled, the autoscroll task should be cancelled. + host_impl_->DidUnregisterScrollbarLayer(scroll_layer->element_id(), + ScrollbarOrientation::VERTICAL); + EXPECT_FALSE(host_impl_->scrollbar_controller_for_testing() + ->AutoscrollTaskIsScheduled()); + + // End the scroll. + host_impl_->MouseUp(gfx::PointF(350, 580)); + host_impl_->ScrollEnd(); + EXPECT_TRUE(!host_impl_->CurrentlyScrollingNode()); + + // Tear down the LayerTreeHostImpl before the InputHandlerClient. + host_impl_->ReleaseLayerTreeFrameSink(); + host_impl_ = nullptr; +} + // Tests that a pointerdown followed by pointermove(s) produces // InputHandlerPointerResult with scroll_offset > 0 even though the GSB might // have been dispatched *after* the first pointermove was handled by the // ScrollbarController. -TEST_F(LayerTreeHostImplTest, PointerMoveOutOfSequence) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, PointerMoveOutOfSequence) { LayerTreeSettings settings = DefaultSettings(); settings.compositor_threaded_scrollbar_scrolling = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -12701,7 +13175,7 @@ TEST_F(LayerTreeHostImplTest, PointerMoveOutOfSequence) { // PointerDown sets up the state needed to initiate a drag. Although, the // resulting GSB won't be dispatched until the next VSync. Hence, the // CurrentlyScrollingNode is expected to be null. - host_impl_->MouseDown(gfx::PointF(350, 18), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 18), /*jump_key_modifier*/ false); EXPECT_TRUE(!host_impl_->CurrentlyScrollingNode()); // PointerMove arrives before the next VSync. This still needs to be handled @@ -12740,7 +13214,7 @@ TEST_F(LayerTreeHostImplTest, PointerMoveOutOfSequence) { } // This tests that faded-out Mac scrollbars can't be interacted with. -TEST_F(LayerTreeHostImplTest, FadedOutPaintedScrollbarHitTest) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, FadedOutPaintedScrollbarHitTest) { LayerTreeSettings settings = DefaultSettings(); settings.compositor_threaded_scrollbar_scrolling = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -12774,14 +13248,14 @@ TEST_F(LayerTreeHostImplTest, FadedOutPaintedScrollbarHitTest) { // scroll. scrollbar->set_scrollbar_painted_opacity(0); InputHandlerPointerResult result = - host_impl_->MouseDown(gfx::PointF(350, 100), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 100), /*jump_key_modifier*/ false); EXPECT_EQ(result.scroll_offset.y(), 0u); // MouseDown on the track of a scrollbar with opacity > 0 should produce a // scroll. scrollbar->set_scrollbar_painted_opacity(1); result = - host_impl_->MouseDown(gfx::PointF(350, 100), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 100), /*jump_key_modifier*/ false); EXPECT_GT(result.scroll_offset.y(), 0u); // Tear down the LayerTreeHostImpl before the InputHandlerClient. @@ -12789,7 +13263,8 @@ TEST_F(LayerTreeHostImplTest, FadedOutPaintedScrollbarHitTest) { host_impl_ = nullptr; } -TEST_F(LayerTreeHostImplTest, SingleGSUForScrollbarThumbDragPerFrame) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SingleGSUForScrollbarThumbDragPerFrame) { LayerTreeSettings settings = DefaultSettings(); settings.compositor_threaded_scrollbar_scrolling = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -12839,7 +13314,7 @@ TEST_F(LayerTreeHostImplTest, SingleGSUForScrollbarThumbDragPerFrame) { // MouseDown on the thumb should not produce a scroll. InputHandlerPointerResult result = - host_impl_->MouseDown(gfx::PointF(350, 18), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 18), /*jump_key_modifier*/ false); EXPECT_EQ(result.scroll_offset.y(), 0u); // The first request for a GSU should be processed as expected. @@ -12875,9 +13350,176 @@ TEST_F(LayerTreeHostImplTest, SingleGSUForScrollbarThumbDragPerFrame) { host_impl_ = nullptr; } +// Tests that the scheduled autoscroll task aborts if a 2nd mousedown occurs in +// the same frame. +TEST_F(LayerTreeHostImplTest, AutoscrollTaskAbort) { + LayerTreeSettings settings = DefaultSettings(); + settings.compositor_threaded_scrollbar_scrolling = true; + CreateHostImpl(settings, CreateLayerTreeFrameSink()); + + // Setup the viewport. + const gfx::Size viewport_size = gfx::Size(360, 600); + const gfx::Size content_size = gfx::Size(345, 3800); + SetupViewportLayersOuterScrolls(viewport_size, content_size); + LayerImpl* scroll_layer = OuterViewportScrollLayer(); + + // Set up the scrollbar and its dimensions. + LayerTreeImpl* layer_tree_impl = host_impl_->active_tree(); + auto* scrollbar = AddLayer<PaintedScrollbarLayerImpl>( + layer_tree_impl, VERTICAL, /*is_left_side_vertical_scrollbar*/ false, + /*is_overlay*/ false); + + SetupScrollbarLayer(scroll_layer, scrollbar); + const gfx::Size scrollbar_size = gfx::Size(15, 600); + scrollbar->SetBounds(scrollbar_size); + host_impl_->set_force_smooth_wheel_scrolling_for_testing(true); + + // Set up the thumb dimensions. + scrollbar->SetThumbThickness(15); + scrollbar->SetThumbLength(50); + scrollbar->SetTrackRect(gfx::Rect(0, 15, 15, 575)); + + // Set up scrollbar arrows. + scrollbar->SetBackButtonRect( + gfx::Rect(gfx::Point(345, 0), gfx::Size(15, 15))); + scrollbar->SetForwardButtonRect( + gfx::Rect(gfx::Point(345, 570), gfx::Size(15, 15))); + scrollbar->SetOffsetToTransformParent(gfx::Vector2dF(345, 0)); + + TestInputHandlerClient input_handler_client; + host_impl_->BindToClient(&input_handler_client); + + { + // An autoscroll task gets scheduled on mousedown. + InputHandlerPointerResult result = host_impl_->MouseDown( + gfx::PointF(350, 575), /*jump_key_modifier*/ false); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + auto begin_state = BeginState(gfx::Point(350, 575), gfx::Vector2d(0, 40), + ui::ScrollInputType::kScrollbar); + EXPECT_EQ( + InputHandler::SCROLL_ON_IMPL_THREAD, + host_impl_ + ->ScrollBegin(begin_state.get(), ui::ScrollInputType::kScrollbar) + .thread); + EXPECT_TRUE(host_impl_->scrollbar_controller_for_testing() + ->AutoscrollTaskIsScheduled()); + } + + { + // Another mousedown occurs in the same frame. InputHandlerProxy calls + // LayerTreeHostImpl::ScrollEnd and the autoscroll task should be cancelled. + InputHandlerPointerResult result = host_impl_->MouseDown( + gfx::PointF(350, 575), /*jump_key_modifier*/ false); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + host_impl_->ScrollEnd(); + EXPECT_FALSE(host_impl_->scrollbar_controller_for_testing() + ->AutoscrollTaskIsScheduled()); + } + + // Tear down the LayerTreeHostImpl before the InputHandlerClient. + host_impl_->ReleaseLayerTreeFrameSink(); + host_impl_ = nullptr; +} + +// Tests that the ScrollbarController handles jump clicks. +TEST_F(LayerTreeHostImplTest, JumpOnScrollbarClick) { + LayerTreeSettings settings = DefaultSettings(); + settings.compositor_threaded_scrollbar_scrolling = true; + CreateHostImpl(settings, CreateLayerTreeFrameSink()); + + // Setup the viewport. + const gfx::Size viewport_size = gfx::Size(360, 600); + const gfx::Size content_size = gfx::Size(345, 3800); + SetupViewportLayersOuterScrolls(viewport_size, content_size); + LayerImpl* scroll_layer = OuterViewportScrollLayer(); + + // Set up the scrollbar and its dimensions. + LayerTreeImpl* layer_tree_impl = host_impl_->active_tree(); + auto* scrollbar = AddLayer<PaintedScrollbarLayerImpl>( + layer_tree_impl, VERTICAL, /*is_left_side_vertical_scrollbar*/ false, + /*is_overlay*/ false); + + SetupScrollbarLayer(scroll_layer, scrollbar); + const gfx::Size scrollbar_size = gfx::Size(15, 600); + scrollbar->SetBounds(scrollbar_size); + host_impl_->set_force_smooth_wheel_scrolling_for_testing(true); + + // Set up the thumb dimensions. + scrollbar->SetThumbThickness(15); + scrollbar->SetThumbLength(50); + scrollbar->SetTrackRect(gfx::Rect(0, 15, 15, 575)); + + // Set up scrollbar arrows. + scrollbar->SetBackButtonRect( + gfx::Rect(gfx::Point(345, 0), gfx::Size(15, 15))); + scrollbar->SetForwardButtonRect( + gfx::Rect(gfx::Point(345, 570), gfx::Size(15, 15))); + scrollbar->SetOffsetToTransformParent(gfx::Vector2dF(345, 0)); + + TestInputHandlerClient input_handler_client; + host_impl_->BindToClient(&input_handler_client); + + // Verify all 4 combinations of JumpOnTrackClick and jump_key_modifier. + { + // Click on track when JumpOnTrackClick is false and jump_key_modifier is + // false. Expected to perform a regular track scroll. + scrollbar->SetJumpOnTrackClick(false); + InputHandlerPointerResult result = host_impl_->MouseDown( + gfx::PointF(350, 400), /*jump_key_modifier*/ false); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 525); + result = host_impl_->MouseUp(gfx::PointF(350, 400)); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 0); + } + + { + // Click on track when JumpOnTrackClick is false and jump_key_modifier is + // true. Expected to perform scroller jump to the clicked location. + scrollbar->SetJumpOnTrackClick(false); + InputHandlerPointerResult result = host_impl_->MouseDown( + gfx::PointF(350, 400), /*jump_key_modifier*/ true); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 2194); + result = host_impl_->MouseUp(gfx::PointF(350, 400)); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 0); + } + + { + // Click on track when JumpOnTrackClick is true and jump_key_modifier is + // false. Expected to perform scroller jump to the clicked location. + scrollbar->SetJumpOnTrackClick(true); + InputHandlerPointerResult result = host_impl_->MouseDown( + gfx::PointF(350, 400), /*jump_key_modifier*/ false); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 2194); + result = host_impl_->MouseUp(gfx::PointF(350, 400)); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 0); + } + + { + // Click on track when JumpOnTrackClick is true and jump_key_modifier is + // true. Expected to perform a regular track scroll. + scrollbar->SetJumpOnTrackClick(true); + InputHandlerPointerResult result = host_impl_->MouseDown( + gfx::PointF(350, 400), /*jump_key_modifier*/ true); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 525); + result = host_impl_->MouseUp(gfx::PointF(350, 400)); + EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); + EXPECT_EQ(result.scroll_offset.y(), 0); + } + + // Tear down the LayerTreeHostImpl before the InputHandlerClient. + host_impl_->ReleaseLayerTreeFrameSink(); + host_impl_ = nullptr; +} + // Tests that an animated scrollbar scroll aborts when a different device (like // a mousewheel) wants to animate the scroll offset. -TEST_F(LayerTreeHostImplTest, AnimatedScrollYielding) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, AnimatedScrollYielding) { LayerTreeSettings settings = DefaultSettings(); settings.compositor_threaded_scrollbar_scrolling = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -12919,7 +13561,7 @@ TEST_F(LayerTreeHostImplTest, AnimatedScrollYielding) { { // Set up an animated scrollbar autoscroll. host_impl_->scrollbar_controller_for_testing()->HandlePointerDown( - gfx::PointF(350, 560), /*shift_modifier*/ false); + gfx::PointF(350, 560), /*jump_key_modifier*/ false); auto begin_state = BeginState(gfx::Point(350, 560), gfx::Vector2d(0, 40), ui::ScrollInputType::kScrollbar); EXPECT_EQ( @@ -12981,7 +13623,7 @@ TEST_F(LayerTreeHostImplTest, AnimatedScrollYielding) { // Tests that changing the scroller length in the middle of a thumb drag doesn't // cause the scroller to jump. -TEST_F(LayerTreeHostImplTest, ThumbDragScrollerLengthIncrease) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ThumbDragScrollerLengthIncrease) { LayerTreeSettings settings = DefaultSettings(); settings.compositor_threaded_scrollbar_scrolling = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -13028,7 +13670,7 @@ TEST_F(LayerTreeHostImplTest, ThumbDragScrollerLengthIncrease) { begin_frame_args.frame_id.sequence_number++; host_impl_->WillBeginImplFrame(begin_frame_args); InputHandlerPointerResult result = - host_impl_->MouseDown(gfx::PointF(350, 18), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 18), /*jump_key_modifier*/ false); EXPECT_EQ(result.scroll_offset.y(), 0); EXPECT_EQ(result.type, PointerResultType::kScrollbarScroll); host_impl_->DidFinishImplFrame(begin_frame_args); @@ -13082,7 +13724,7 @@ TEST_F(LayerTreeHostImplTest, ThumbDragScrollerLengthIncrease) { host_impl_ = nullptr; } -TEST_F(LayerTreeHostImplTest, MainThreadFallback) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, MainThreadFallback) { LayerTreeSettings settings = DefaultSettings(); settings.compositor_threaded_scrollbar_scrolling = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -13118,7 +13760,7 @@ TEST_F(LayerTreeHostImplTest, MainThreadFallback) { // Clicking on the track should produce a scroll on the compositor thread. InputHandlerPointerResult compositor_threaded_scrolling_result = - host_impl_->MouseDown(gfx::PointF(350, 500), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 500), /*jump_key_modifier*/ false); host_impl_->MouseUp(gfx::PointF(350, 500)); EXPECT_EQ(compositor_threaded_scrolling_result.scroll_offset.y(), 525u); EXPECT_FALSE(GetScrollNode(scroll_layer)->main_thread_scrolling_reasons); @@ -13129,7 +13771,7 @@ TEST_F(LayerTreeHostImplTest, MainThreadFallback) { GetScrollNode(scroll_layer)->main_thread_scrolling_reasons = MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects; compositor_threaded_scrolling_result = - host_impl_->MouseDown(gfx::PointF(350, 500), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(350, 500), /*jump_key_modifier*/ false); host_impl_->MouseUp(gfx::PointF(350, 500)); EXPECT_EQ(compositor_threaded_scrolling_result.scroll_offset.y(), 0u); @@ -13138,7 +13780,8 @@ TEST_F(LayerTreeHostImplTest, MainThreadFallback) { host_impl_ = nullptr; } -TEST_F(LayerTreeHostImplTest, SecondScrollAnimatedBeginNotIgnored) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SecondScrollAnimatedBeginNotIgnored) { const gfx::Size content_size(1000, 1000); const gfx::Size viewport_size(50, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -13165,7 +13808,8 @@ TEST_F(LayerTreeHostImplTest, SecondScrollAnimatedBeginNotIgnored) { // Verfify that a smooth scroll animation doesn't jump when UpdateTarget gets // called before the animation is started. -TEST_F(LayerTreeHostImplTest, AnimatedScrollUpdateTargetBeforeStarting) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + AnimatedScrollUpdateTargetBeforeStarting) { const gfx::Size content_size(1000, 1000); const gfx::Size viewport_size(50, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -13223,7 +13867,7 @@ TEST_F(LayerTreeHostImplTest, AnimatedScrollUpdateTargetBeforeStarting) { EXPECT_TRUE(y > 1 && y < 49); } -TEST_F(LayerTreeHostImplTest, ScrollAnimatedWithDelay) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, ScrollAnimatedWithDelay) { const gfx::Size content_size(1000, 1000); const gfx::Size viewport_size(50, 100); SetupViewportLayersOuterScrolls(viewport_size, content_size); @@ -13752,7 +14396,7 @@ TEST_F(LayerTreeHostImplTimelinesTest, ScrollAnimatedChangingBounds) { EXPECT_EQ(gfx::ScrollOffset(250, 250), CurrentScrollOffset(scrolling_layer)); } -TEST_F(LayerTreeHostImplTest, InvalidLayerNotAddedToRasterQueue) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, InvalidLayerNotAddedToRasterQueue) { CreatePendingTree(); Region empty_invalidation; @@ -13786,7 +14430,7 @@ TEST_F(LayerTreeHostImplTest, InvalidLayerNotAddedToRasterQueue) { EXPECT_TRUE(empty_raster_priority_queue_all->IsEmpty()); } -TEST_F(LayerTreeHostImplTest, DidBecomeActive) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, DidBecomeActive) { CreatePendingTree(); host_impl_->ActivateSyncTree(); CreatePendingTree(); @@ -13819,7 +14463,8 @@ TEST_F(LayerTreeHostImplTest, DidBecomeActive) { EXPECT_EQ(2u, raw_mask_layer->did_become_active_call_count()); } -TEST_F(LayerTreeHostImplTest, WheelScrollWithPageScaleFactorOnInnerLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + WheelScrollWithPageScaleFactorOnInnerLayer) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); auto* scroll_layer = InnerViewportScrollLayer(); host_impl_->active_tree()->SetDeviceViewportRect(gfx::Rect(50, 50)); @@ -13892,7 +14537,7 @@ size_t CountRenderPassesWithId(const viz::RenderPassList& list, [id](const std::unique_ptr<viz::RenderPass>& p) { return p->id == id; }); } -TEST_F(LayerTreeHostImplTest, RemoveUnreferencedRenderPass) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RemoveUnreferencedRenderPass) { TestFrameData frame; frame.render_passes.push_back(viz::RenderPass::Create()); viz::RenderPass* pass3 = frame.render_passes.back().get(); @@ -13927,7 +14572,7 @@ TEST_F(LayerTreeHostImplTest, RemoveUnreferencedRenderPass) { EXPECT_EQ(1u, frame.render_passes[0]->id); } -TEST_F(LayerTreeHostImplTest, RemoveEmptyRenderPass) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RemoveEmptyRenderPass) { TestFrameData frame; frame.render_passes.push_back(viz::RenderPass::Create()); viz::RenderPass* pass3 = frame.render_passes.back().get(); @@ -13968,7 +14613,7 @@ TEST_F(LayerTreeHostImplTest, RemoveEmptyRenderPass) { pass1->quad_list.ElementAt(0)->material); } -TEST_F(LayerTreeHostImplTest, DoNotRemoveEmptyRootRenderPass) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, DoNotRemoveEmptyRootRenderPass) { TestFrameData frame; frame.render_passes.push_back(viz::RenderPass::Create()); viz::RenderPass* pass3 = frame.render_passes.back().get(); @@ -14024,7 +14669,7 @@ class FakeVideoFrameController : public VideoFrameController { bool did_draw_frame_ = false; }; -TEST_F(LayerTreeHostImplTest, AddVideoFrameControllerInsideFrame) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, AddVideoFrameControllerInsideFrame) { viz::BeginFrameArgs begin_frame_args = viz::CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2); FakeVideoFrameController controller; @@ -14047,7 +14692,8 @@ TEST_F(LayerTreeHostImplTest, AddVideoFrameControllerInsideFrame) { EXPECT_FALSE(controller.did_draw_frame()); } -TEST_F(LayerTreeHostImplTest, AddVideoFrameControllerOutsideFrame) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + AddVideoFrameControllerOutsideFrame) { viz::BeginFrameArgs begin_frame_args = viz::CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2); FakeVideoFrameController controller; @@ -14078,7 +14724,8 @@ TEST_F(LayerTreeHostImplTest, AddVideoFrameControllerOutsideFrame) { } // Tests that SetDeviceScaleFactor correctly impacts GPU rasterization. -TEST_F(LayerTreeHostImplTest, GpuRasterizationStatusDeviceScaleFactor) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + GpuRasterizationStatusDeviceScaleFactor) { // Create a host impl with MSAA support (4 samples). LayerTreeSettings msaaSettings = DefaultSettings(); msaaSettings.gpu_rasterization_msaa_sample_count = -1; @@ -14108,7 +14755,8 @@ TEST_F(LayerTreeHostImplTest, GpuRasterizationStatusDeviceScaleFactor) { } // Tests that explicit MSAA sample count correctly impacts GPU rasterization. -TEST_F(LayerTreeHostImplTest, GpuRasterizationStatusExplicitMSAACount) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + GpuRasterizationStatusExplicitMSAACount) { // Create a host impl with MSAA support and a forced sample count of 4. LayerTreeSettings msaaSettings = DefaultSettings(); msaaSettings.gpu_rasterization_msaa_sample_count = 4; @@ -14245,7 +14893,7 @@ TEST_F(MsaaCompatibilityLayerTreeHostImplTest, 0); } -TEST_F(LayerTreeHostImplTest, UpdatePageScaleFactorOnActiveTree) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, UpdatePageScaleFactorOnActiveTree) { // Check page scale factor update in property trees when an update is made // on the active tree. CreatePendingTree(); @@ -14293,7 +14941,8 @@ TEST_F(LayerTreeHostImplTest, UpdatePageScaleFactorOnActiveTree) { EXPECT_EQ(gfx::Point3F(), active_tree_node->origin); } -TEST_F(LayerTreeHostImplTest, SubLayerScaleForNodeInSubtreeOfPageScaleLayer) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SubLayerScaleForNodeInSubtreeOfPageScaleLayer) { // Checks that the sublayer scale of a transform node in the subtree of the // page scale layer is updated without a property tree rebuild. host_impl_->active_tree()->PushPageScaleFromMainThread(1, 1, 3); @@ -14321,7 +14970,8 @@ TEST_F(LayerTreeHostImplTest, SubLayerScaleForNodeInSubtreeOfPageScaleLayer) { // Checks that if we lose a GPU raster enabled LayerTreeFrameSink and replace // it with a software LayerTreeFrameSink, LayerTreeHostImpl correctly // re-computes GPU rasterization status. -TEST_F(LayerTreeHostImplTest, RecomputeGpuRasterOnLayerTreeFrameSinkChange) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + RecomputeGpuRasterOnLayerTreeFrameSinkChange) { host_impl_->ReleaseLayerTreeFrameSink(); host_impl_ = nullptr; @@ -14533,7 +15183,7 @@ void LayerTreeHostImplTest::SetupMouseMoveAtTestScrollbarStates( animation_task_.Reset(); // Only the MouseMove's location will affect the overlay scrollbar. - host_impl_->MouseDown(gfx::PointF(60, 50), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(60, 50), /*jump_key_modifier*/ false); host_impl_->MouseMoveAt(gfx::Point(60, 50)); host_impl_->MouseUp(gfx::PointF(60, 50)); @@ -14544,29 +15194,30 @@ void LayerTreeHostImplTest::SetupMouseMoveAtTestScrollbarStates( host_impl_->MouseMoveAt(gfx::Point(40, 150)); animation_task_.Reset(); - host_impl_->MouseDown(gfx::PointF(40, 150), /*shift_modifier*/ false); + host_impl_->MouseDown(gfx::PointF(40, 150), /*jump_key_modifier*/ false); host_impl_->MouseUp(gfx::PointF(40, 150)); EXPECT_TRUE(animation_task_.is_null()); // Near scrollbar_1, then mouse down and unregister // scrollbar_2_animation_controller, then mouse up should not cause crash. host_impl_->MouseMoveAt(gfx::Point(40, 150)); - host_impl_->MouseDown(gfx::PointF(40, 150), /*shift_modifier*/ false); - host_impl_->DidUnregisterScrollbarLayer(root_scroll->element_id()); + host_impl_->MouseDown(gfx::PointF(40, 150), /*jump_key_modifier*/ false); + host_impl_->DidUnregisterScrollbarLayer(root_scroll->element_id(), + ScrollbarOrientation::VERTICAL); host_impl_->MouseUp(gfx::PointF(40, 150)); } -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, LayerTreeHostImplTestScrollbarStatesInMainThreadScrolling) { SetupMouseMoveAtTestScrollbarStates(true); } -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, LayerTreeHostImplTestScrollbarStatesInNotMainThreadScrolling) { SetupMouseMoveAtTestScrollbarStates(false); } -TEST_F(LayerTreeHostImplTest, CheckerImagingTileInvalidation) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, CheckerImagingTileInvalidation) { LayerTreeSettings settings = LegacySWSettings(); settings.commit_to_active_tree = false; settings.enable_checker_imaging = true; @@ -14651,7 +15302,7 @@ TEST_F(LayerTreeHostImplTest, CheckerImagingTileInvalidation) { EXPECT_EQ(expected_invalidation, *(root->GetPendingInvalidation())); } -TEST_F(LayerTreeHostImplTest, RasterColorSpace) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RasterColorSpace) { LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); // The default raster color space should be sRGB. @@ -14666,7 +15317,7 @@ TEST_F(LayerTreeHostImplTest, RasterColorSpace) { gfx::ColorSpace::CreateDisplayP3D65()); } -TEST_F(LayerTreeHostImplTest, RasterColorSpaceSoftware) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RasterColorSpaceSoftware) { LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, FakeLayerTreeFrameSink::CreateSoftware()); // Software composited resources should always use sRGB as their color space. @@ -14680,7 +15331,7 @@ TEST_F(LayerTreeHostImplTest, RasterColorSpaceSoftware) { gfx::ColorSpace::CreateSRGB()); } -TEST_F(LayerTreeHostImplTest, RasterColorPrefersSRGB) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RasterColorPrefersSRGB) { auto p3 = gfx::ColorSpace::CreateDisplayP3D65(); LayerTreeSettings settings = DefaultSettings(); @@ -14697,7 +15348,7 @@ TEST_F(LayerTreeHostImplTest, RasterColorPrefersSRGB) { EXPECT_EQ(host_impl_->GetRasterColorSpace(gfx::ContentColorUsage::kSRGB), p3); } -TEST_F(LayerTreeHostImplTest, UpdatedTilingsForNonDrawingLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, UpdatedTilingsForNonDrawingLayers) { gfx::Size layer_bounds(500, 500); CreatePendingTree(); @@ -14749,7 +15400,8 @@ TEST_F(LayerTreeHostImplTest, UpdatedTilingsForNonDrawingLayers) { ->can_require_tiles_for_activation()); } -TEST_F(LayerTreeHostImplTest, RasterTilePrioritizationForNonDrawingLayers) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + RasterTilePrioritizationForNonDrawingLayers) { gfx::Size layer_bounds(500, 500); CreatePendingTree(); auto* root = @@ -14811,7 +15463,7 @@ TEST_F(LayerTreeHostImplTest, RasterTilePrioritizationForNonDrawingLayers) { EXPECT_EQ(queue->Top().tile()->layer_id(), 3); } -TEST_F(LayerTreeHostImplTest, DrawAfterDroppingTileResources) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, DrawAfterDroppingTileResources) { LayerTreeSettings settings = DefaultSettings(); settings.using_synchronous_renderer_compositor = true; CreateHostImpl(settings, CreateLayerTreeFrameSink()); @@ -14845,20 +15497,20 @@ TEST_F(LayerTreeHostImplTest, DrawAfterDroppingTileResources) { EXPECT_GT(layer->tilings()->num_tilings(), 0u); } -TEST_F(LayerTreeHostImplTest, WhiteListedTouchActionTest1) { - WhiteListedTouchActionTestHelper(1.0f, 1.0f); +TEST_P(ScrollUnifiedLayerTreeHostImplTest, AllowedTouchActionTest1) { + AllowedTouchActionTestHelper(1.0f, 1.0f); } -TEST_F(LayerTreeHostImplTest, WhiteListedTouchActionTest2) { - WhiteListedTouchActionTestHelper(1.0f, 0.789f); +TEST_P(ScrollUnifiedLayerTreeHostImplTest, AllowedTouchActionTest2) { + AllowedTouchActionTestHelper(1.0f, 0.789f); } -TEST_F(LayerTreeHostImplTest, WhiteListedTouchActionTest3) { - WhiteListedTouchActionTestHelper(2.345f, 1.0f); +TEST_P(ScrollUnifiedLayerTreeHostImplTest, AllowedTouchActionTest3) { + AllowedTouchActionTestHelper(2.345f, 1.0f); } -TEST_F(LayerTreeHostImplTest, WhiteListedTouchActionTest4) { - WhiteListedTouchActionTestHelper(2.654f, 0.678f); +TEST_P(ScrollUnifiedLayerTreeHostImplTest, AllowedTouchActionTest4) { + AllowedTouchActionTestHelper(2.654f, 0.678f); } // Test implementation of RenderFrameMetadataObserver which can optionally @@ -14893,7 +15545,7 @@ class TestRenderFrameMetadataObserver : public RenderFrameMetadataObserver { base::Optional<RenderFrameMetadata> last_metadata_; }; -TEST_F(LayerTreeHostImplTest, RenderFrameMetadata) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, RenderFrameMetadata) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); host_impl_->active_tree()->SetDeviceViewportRect(gfx::Rect(50, 50)); host_impl_->active_tree()->PushPageScaleFromMainThread(1, 0.5f, 4); @@ -15026,7 +15678,8 @@ TEST_F(LayerTreeHostImplTest, RenderFrameMetadata) { } } -TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToRenderFrameMetadata) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + SelectionBoundsPassedToRenderFrameMetadata) { LayerImpl* root = SetupDefaultRootLayer(gfx::Size(10, 10)); UpdateDrawProperties(host_impl_->active_tree()); @@ -15078,7 +15731,7 @@ TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToRenderFrameMetadata) { EXPECT_TRUE(selection_2.end.visible()); } -TEST_F(LayerTreeHostImplTest, +TEST_P(ScrollUnifiedLayerTreeHostImplTest, VerticalScrollDirectionChangesPassedToRenderFrameMetadata) { // Set up the viewport. SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); @@ -15166,7 +15819,8 @@ TEST_F(LayerTreeHostImplTest, // Tests ScrollUpdate() to see if the method sets the scroll tree's currently // scrolling node. -TEST_F(LayerTreeHostImplTest, ScrollUpdateDoesNotSetScrollingNode) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ScrollUpdateDoesNotSetScrollingNode) { SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); UpdateDrawProperties(host_impl_->active_tree()); @@ -15531,7 +16185,8 @@ TEST_F(HitTestRegionListGeneratingLayerTreeHostImplTest, InvalidFrameSinkId) { hit_test_region_list->regions[0].rect.ToString()); } -TEST_F(LayerTreeHostImplTest, ImplThreadPhaseUponImplSideInvalidation) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, + ImplThreadPhaseUponImplSideInvalidation) { LayerTreeSettings settings = DefaultSettings(); CreateHostImpl(settings, CreateLayerTreeFrameSink()); // In general invalidation should never be ran outside the impl frame. @@ -15552,7 +16207,7 @@ TEST_F(LayerTreeHostImplTest, ImplThreadPhaseUponImplSideInvalidation) { // Test passes when there is no crash. } -TEST_F(LayerTreeHostImplTest, SkipOnDrawDoesNotUpdateDrawParams) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, SkipOnDrawDoesNotUpdateDrawParams) { EXPECT_TRUE(CreateHostImpl(DefaultSettings(), FakeLayerTreeFrameSink::CreateSoftware())); SetupViewportLayersInnerScrolls(gfx::Size(50, 50), gfx::Size(100, 100)); @@ -15581,7 +16236,7 @@ TEST_F(LayerTreeHostImplTest, SkipOnDrawDoesNotUpdateDrawParams) { // Test that a touch scroll over a SolidColorScrollbarLayer, the scrollbar used // on Android, does not register as a scrollbar scroll and result in main // threaded scrolling. -TEST_F(LayerTreeHostImplTest, TouchScrollOnAndroidScrollbar) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, TouchScrollOnAndroidScrollbar) { LayerTreeImpl* layer_tree_impl = host_impl_->active_tree(); gfx::Size viewport_size = gfx::Size(360, 600); gfx::Size scroll_content_size = gfx::Size(360, 3800); @@ -15786,7 +16441,7 @@ TEST_F(ForceActivateAfterPaintWorkletPaintLayerTreeHostImplTest, // Verify that the device scale factor is not used to rescale scrollbar deltas // in percent-based scrolling. -TEST_F(LayerTreeHostImplTest, PercentBasedScrollbarDeltasDSF3) { +TEST_P(ScrollUnifiedLayerTreeHostImplTest, PercentBasedScrollbarDeltasDSF3) { LayerTreeSettings settings = DefaultSettings(); settings.percent_based_scrolling = true; settings.use_zoom_for_dsf = true; @@ -15798,21 +16453,21 @@ TEST_F(LayerTreeHostImplTest, PercentBasedScrollbarDeltasDSF3) { LayerImpl* content_layer = AddContentLayer(); LayerImpl* scroll_layer = AddScrollableLayer( - content_layer, gfx::Size(185, 200), gfx::Size(185, 3800)); + content_layer, gfx::Size(185, 500), gfx::Size(185, 3800)); auto* scrollbar = AddLayer<PaintedScrollbarLayerImpl>( host_impl_->active_tree(), VERTICAL, false, true); SetupScrollbarLayer(scroll_layer, scrollbar); - scrollbar->SetBounds(gfx::Size(15, 200)); + scrollbar->SetBounds(gfx::Size(15, 500)); scrollbar->SetThumbThickness(15); scrollbar->SetThumbLength(50); - scrollbar->SetTrackRect(gfx::Rect(0, 15, 15, 185)); + scrollbar->SetTrackRect(gfx::Rect(0, 15, 15, 485)); scrollbar->SetBackButtonRect(gfx::Rect(gfx::Point(0, 0), gfx::Size(15, 15))); scrollbar->SetForwardButtonRect( - gfx::Rect(gfx::Point(0, 185), gfx::Size(15, 15))); + gfx::Rect(gfx::Point(0, 485), gfx::Size(15, 15))); scrollbar->SetOffsetToTransformParent(gfx::Vector2dF(185, 0)); DrawFrame(); @@ -15821,13 +16476,13 @@ TEST_F(LayerTreeHostImplTest, PercentBasedScrollbarDeltasDSF3) { host_impl_->BindToClient(&input_handler_client); // Test scrolling with device scale factor = 3. - const float expected_delta = kPercentDeltaForDirectionalScroll * 200u; + const float expected_delta = floorf(kPercentDeltaForDirectionalScroll * 500); host_impl_->active_tree()->set_painted_device_scale_factor(3); InputHandlerPointerResult scroll_result = - host_impl_->MouseDown(gfx::PointF(190, 190), false); - host_impl_->MouseUp(gfx::PointF(190, 190)); + host_impl_->MouseDown(gfx::PointF(190, 490), false); + host_impl_->MouseUp(gfx::PointF(190, 490)); EXPECT_EQ(scroll_result.scroll_offset.y(), expected_delta); EXPECT_FALSE(GetScrollNode(scroll_layer)->main_thread_scrolling_reasons); @@ -15837,8 +16492,8 @@ TEST_F(LayerTreeHostImplTest, PercentBasedScrollbarDeltasDSF3) { host_impl_->active_tree()->set_painted_device_scale_factor(1); InputHandlerPointerResult scroll_with_dsf_1 = - host_impl_->MouseDown(gfx::PointF(190, 190), false); - host_impl_->MouseUp(gfx::PointF(190, 190)); + host_impl_->MouseDown(gfx::PointF(190, 490), false); + host_impl_->MouseUp(gfx::PointF(190, 490)); EXPECT_EQ(scroll_with_dsf_1.scroll_offset.y(), expected_delta); EXPECT_FALSE(GetScrollNode(scroll_layer)->main_thread_scrolling_reasons); @@ -15848,5 +16503,497 @@ TEST_F(LayerTreeHostImplTest, PercentBasedScrollbarDeltasDSF3) { host_impl_ = nullptr; } +class UnifiedScrollingTest : public LayerTreeHostImplTest { + public: + using Point = gfx::Point; + using ScrollInputType = ui::ScrollInputType; + using ScrollOffset = gfx::ScrollOffset; + using ScrollStatus = InputHandler::ScrollStatus; + using Size = gfx::Size; + using Rect = gfx::Rect; + using Vector2d = gfx::Vector2d; + + void SetUp() override { + scoped_feature_list.InitAndEnableFeature(features::kScrollUnification); + LayerTreeHostImplTest::SetUp(); + + cur_time_ = base::TimeTicks() + base::TimeDelta::FromMilliseconds(100); + begin_frame_args_ = + viz::CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1); + + SetupViewportLayersOuterScrolls(gfx::Size(100, 100), gfx::Size(200, 200)); + } + + void CreateUncompositedScrollerAndNonFastScrollableRegion() { + // Create an uncompositd scroll node that corresponds to a non fast + // scrollable region on the outer viewport scroll layer. + Size scrollable_content_bounds(100, 100); + Size container_bounds(50, 50); + CreateScrollNodeForUncompositedScroller( + GetPropertyTrees(), host_impl_->OuterViewportScrollNode()->id, + ScrollerElementId(), scrollable_content_bounds, container_bounds); + OuterViewportScrollLayer()->SetNonFastScrollableRegion(Rect(0, 0, 50, 50)); + + host_impl_->active_tree()->set_needs_update_draw_properties(); + UpdateDrawProperties(host_impl_->active_tree()); + host_impl_->active_tree()->DidBecomeActive(); + DrawFrame(); + } + + void CreateScroller(uint32_t main_thread_scrolling_reasons) { + // Creates a regular compositeds scroller that comes with a ScrollNode and + // Layer. + Size scrollable_content_bounds(100, 100); + Size container_bounds(50, 50); + + LayerImpl* layer = + AddScrollableLayer(OuterViewportScrollLayer(), container_bounds, + scrollable_content_bounds); + scroller_layer_ = layer; + GetScrollNode(layer)->main_thread_scrolling_reasons = + main_thread_scrolling_reasons; + GetScrollNode(layer)->is_composited = true; + + UpdateDrawProperties(host_impl_->active_tree()); + host_impl_->active_tree()->DidBecomeActive(); + DrawFrame(); + } + + void CreateSuashingLayerCoveringWholeViewport() { + // Add a (simulated) "squashing layer". It's scroll parent is the outer + // viewport but it covers the entire viewport and any scrollers underneath + // it. + LayerImpl* squashing_layer = AddLayer(); + squashing_layer->SetBounds(gfx::Size(100, 100)); + squashing_layer->SetDrawsContent(true); + squashing_layer->SetHitTestable(true); + CopyProperties(OuterViewportScrollLayer(), squashing_layer); + UpdateDrawProperties(host_impl_->active_tree()); + } + + ScrollStatus ScrollBegin(const Vector2d& delta) { + auto scroll_state = + BeginState(Point(25, 25), delta, ScrollInputType::kWheel); + ScrollStatus status = + host_impl_->ScrollBegin(scroll_state.get(), ScrollInputType::kWheel); + + if (status.needs_main_thread_hit_test) + to_be_continued_scroll_begin_ = std::move(scroll_state); + + return status; + } + + ScrollStatus ContinuedScrollBegin(ElementId element_id) { + DCHECK(to_be_continued_scroll_begin_) + << "ContinuedScrollBegin needs to come after a ScrollBegin that " + "requested a main frame"; + std::unique_ptr<ScrollState> scroll_state = + std::move(to_be_continued_scroll_begin_); + + scroll_state->data()->set_current_native_scrolling_element(element_id); + scroll_state->data()->is_main_thread_hit_tested = true; + + return host_impl_->ScrollBegin(scroll_state.get(), ScrollInputType::kWheel); + } + + InputHandlerScrollResult ScrollUpdate(const Vector2d& delta) { + auto scroll_state = + UpdateState(Point(25, 25), delta, ScrollInputType::kWheel); + return host_impl_->ScrollUpdate(scroll_state.get()); + } + + InputHandlerScrollResult AnimatedScrollUpdate(const Vector2d& delta) { + auto scroll_state = AnimatedUpdateState(Point(25, 25), delta); + return host_impl_->ScrollUpdate(scroll_state.get()); + } + + void ScrollEnd() { return host_impl_->ScrollEnd(); } + + // An animation is setup in the first BeginFrame so it won't actually update + // in the first one. Use a named method for that so it's clear rather than + // mysteriously calling BeginFrame twice. + void StartAnimation() { BeginFrame(base::TimeDelta()); } + + void BeginFrame(base::TimeDelta forward) { + cur_time_ += forward; + begin_frame_args_.frame_time = cur_time_; + begin_frame_args_.frame_id.sequence_number++; + host_impl_->WillBeginImplFrame(begin_frame_args_); + host_impl_->Animate(); + host_impl_->UpdateAnimationState(true); + host_impl_->DidFinishImplFrame(begin_frame_args_); + } + + ScrollOffset GetScrollOffset(ScrollNode* node) { + return GetPropertyTrees()->scroll_tree.current_scroll_offset( + node->element_id); + } + + ScrollOffset ScrollerOffset() { + return GetPropertyTrees()->scroll_tree.current_scroll_offset( + ScrollerElementId()); + } + + PropertyTrees* GetPropertyTrees() { + return host_impl_->active_tree()->property_trees(); + } + + ScrollNode* CurrentlyScrollingNode() { + return host_impl_->CurrentlyScrollingNode(); + } + + ScrollNode* ScrollerNode() { + ScrollNode* node = GetPropertyTrees()->scroll_tree.FindNodeFromElementId( + ScrollerElementId()); + DCHECK(node); + return node; + } + ElementId ScrollerElementId() const { + if (scroller_layer_) + return scroller_layer_->element_id(); + + return ElementId(1234); + } + + base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16); + + // Parameterized test body. Defined inline with tests. + void TestUncompositedScrollingState(bool mutates_transform_tree); + + private: + LayerImpl* scroller_layer_ = nullptr; + + base::TimeTicks cur_time_; + viz::BeginFrameArgs begin_frame_args_; + + std::unique_ptr<ScrollState> to_be_continued_scroll_begin_; + base::test::ScopedFeatureList scoped_feature_list; +}; + +// A ScrollBegin that hits a non fast scrollable region must return a request +// for a main thread hit test. +TEST_F(UnifiedScrollingTest, UnifiedScrollNonFastScrollableRegion) { + CreateUncompositedScrollerAndNonFastScrollableRegion(); + + // When ScrollUnification is turned on, scrolling inside a non-fast + // scrollable region should request a main thread hit test. It's the client's + // responsibility to request a hit test from Blink. It can then call + // ScrollBegin again, providing the element_id to scroll. + { + ScrollStatus status = ScrollBegin(Vector2d(0, 10)); + + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_TRUE(status.needs_main_thread_hit_test); + + // The scroll hasn't started yet though. + EXPECT_FALSE(CurrentlyScrollingNode()); + } + + // Simulate the scroll hit test coming back from the main thread. This time + // ScrollBegin will be called with an element id provided so that a hit test + // is unnecessary. + { + ScrollStatus status = ContinuedScrollBegin(ScrollerElementId()); + + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + + EXPECT_TRUE(CurrentlyScrollingNode()); + EXPECT_EQ(ScrollerNode(), CurrentlyScrollingNode()); + } + + // Ensure ScrollUpdates can successfully scroll this node. They shouldn't + // mutate the associated transform node. + { + EXPECT_TRUE(ScrollUpdate(Vector2d(0, 10)).did_scroll); + EXPECT_EQ(ScrollOffset(0, 10), ScrollerOffset()); + } + + // Try to scroll past the end. Ensure the max scrolling bounds are respected. + { + EXPECT_TRUE(ScrollUpdate(Vector2d(0, 1000)).did_scroll); + EXPECT_EQ(ScrollOffset(0, 50), ScrollerOffset()); + } + + // Overscrolling should cause the scroll update to be dropped. + { + EXPECT_FALSE(ScrollUpdate(Vector2d(0, 10)).did_scroll); + EXPECT_EQ(ScrollOffset(0, 50), ScrollerOffset()); + } + + host_impl_->ScrollEnd(); +} + +// A main thread hit test should still go through latch bubbling. That is, if +// the hit tested scroller is fully scrolled and cannot consume the scroll, we +// should chain up to its ancestor. +TEST_F(UnifiedScrollingTest, MainThreadHitTestLatchBubbling) { + CreateUncompositedScrollerAndNonFastScrollableRegion(); + + // Start with the scroller fully scrolled. + { + ScrollBegin(Vector2d(0, 1000)); + ContinuedScrollBegin(ScrollerElementId()); + ScrollUpdate(Vector2d(0, 1000)); + ScrollEnd(); + ASSERT_EQ(ScrollOffset(0, 50), ScrollerOffset()); + } + + { + ScrollStatus status = ScrollBegin(Vector2d(0, 10)); + ASSERT_TRUE(status.needs_main_thread_hit_test); + status = ContinuedScrollBegin(ScrollerElementId()); + + // Since the hit tested scroller in ContinuedScrollBegin was fully + // scrolled, we should latch to the viewport instead. + EXPECT_TRUE(CurrentlyScrollingNode()); + EXPECT_EQ(host_impl_->OuterViewportScrollNode(), CurrentlyScrollingNode()); + } +} + +using UnifiedScrollingDeathTest = UnifiedScrollingTest; + +// A main thread hit test that with an empty target id should be dropped. +TEST_F(UnifiedScrollingDeathTest, EmptyMainThreadHitTest) { + ::testing::FLAGS_gtest_death_test_style = "threadsafe"; + CreateUncompositedScrollerAndNonFastScrollableRegion(); + { + ElementId kInvalidId; + DCHECK(!kInvalidId); + + ScrollStatus status = ScrollBegin(Vector2d(0, 10)); + + // Note, we have a NOTREACHED here to make sure this cannot happen. If + // DCHECKs are enabled we can just make sure we get killed when we end up + // in this situation. +#if DCHECK_IS_ON() + EXPECT_DEATH_IF_SUPPORTED({ status = ContinuedScrollBegin(kInvalidId); }, + ""); +#else + status = ContinuedScrollBegin(kInvalidId); + EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer, + status.main_thread_scrolling_reasons); +#endif + } +} + +// A main thread hit test that returns a scroll node we can't find should be +// dropped. +TEST_F(UnifiedScrollingTest, MainThreadHitTestScrollNodeNotFound) { + CreateUncompositedScrollerAndNonFastScrollableRegion(); + + { + ElementId kUnknown(42); + DCHECK(!GetPropertyTrees()->scroll_tree.FindNodeFromElementId(kUnknown)); + + ScrollStatus status = ScrollBegin(Vector2d(0, 10)); + status = ContinuedScrollBegin(kUnknown); + EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer, + status.main_thread_scrolling_reasons); + } +} + +// The presence of a squashing layer is one reason we might "fail to hit test" +// on the compositor. A heuristic is used that if the first hit scrollable +// layer isn't a scrolling ancestor of the first hit layer, we probably hit a +// squashing layer which might have empty regions we don't know how to hit +// test. This requires falling back to the main thread. However, with scroll +// unification, we may still be able to scroll the final scroller entirely on +// the compositor. See LayerTreeHostImpl::IsInitialScrollHitTestReliable. +TEST_F(UnifiedScrollingTest, SquashingLayerCausesMainThreadHitTest) { + // Create a scroller that should scroll on the compositor thread and the add + // "squashing" layer over top of it. This simulates the case where a + // squashing layer obscuring a scroller makes the hit test unreliable. + CreateScroller(MainThreadScrollingReason::kNotScrollingOnMain); + CreateSuashingLayerCoveringWholeViewport(); + + // When ScrollUnification is turned on, scrolling over a squashing-like layer + // that cannot be reliably hit tested on the compositor should request a main + // thread hit test. + { + ScrollStatus status = ScrollBegin(Vector2d(0, 10)); + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_TRUE(status.needs_main_thread_hit_test); + } + + // Resolving the hit test should allow the scroller underneath to scroll as + // normal on the impl thread. + { + ScrollStatus status = ContinuedScrollBegin(ScrollerElementId()); + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + + EXPECT_TRUE(CurrentlyScrollingNode()); + EXPECT_EQ(ScrollerNode(), CurrentlyScrollingNode()); + } +} + +// Under unified scroling, a composited scroller with a main thread scrolling +// reason should be scrolled on the compositor. Ensure ScrollBegin returns +// success without needing a main thread hit test. +TEST_F(UnifiedScrollingTest, MainThreadScrollingReasonsScrollOnCompositor) { + CreateScroller( + MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects); + + { + ScrollStatus status = ScrollBegin(Vector2d(0, 10)); + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + } +} + +// This tests whether or not various kinds of scrolling mutates the transform +// tree or not. It is parameterized and used by tests below. +void UnifiedScrollingTest::TestUncompositedScrollingState( + bool mutates_transform_tree) { + TransformTree& tree = GetPropertyTrees()->transform_tree; + TransformNode* transform_node = tree.Node(ScrollerNode()->transform_id); + + // Ensure we're in a clean state to start. + { + ASSERT_EQ(transform_node->element_id, ScrollerElementId()); + ASSERT_TRUE(transform_node->scrolls); + + ASSERT_EQ(ScrollOffset(0, 0), transform_node->scroll_offset); + ASSERT_FALSE(transform_node->transform_changed); + ASSERT_FALSE(transform_node->needs_local_transform_update); + ASSERT_FALSE(tree.needs_update()); + } + + // Start a scroll, ensure the scroll tree was updated and a commit was + // requested. Check that the transform tree mutation was as expected for the + // test parameter. + { + ScrollStatus status = ScrollBegin(Vector2d(0, 10)); + if (status.needs_main_thread_hit_test) + ContinuedScrollBegin(ScrollerElementId()); + + ASSERT_EQ(ScrollerNode(), CurrentlyScrollingNode()); + + did_request_commit_ = false; + + ScrollUpdate(Vector2d(0, 10)); + ASSERT_EQ(ScrollOffset(0, 10), ScrollerOffset()); + EXPECT_TRUE(did_request_commit_); + + // Ensure the transform tree was updated only if expected. + if (mutates_transform_tree) + EXPECT_EQ(ScrollOffset(0, 10), transform_node->scroll_offset); + else + EXPECT_EQ(ScrollOffset(0, 0), transform_node->scroll_offset); + EXPECT_EQ(mutates_transform_tree, transform_node->transform_changed); + EXPECT_EQ(mutates_transform_tree, + transform_node->needs_local_transform_update); + EXPECT_EQ(mutates_transform_tree, tree.needs_update()); + } + + // Perform animated scroll update. Ensure the same things. + { + did_request_commit_ = false; + + AnimatedScrollUpdate(Vector2d(0, 10)); + ASSERT_TRUE(host_impl_->mutator_host()->ImplOnlyScrollAnimatingElement()); + ASSERT_EQ(ScrollOffset(0, 10), ScrollerOffset()); + + StartAnimation(); + BeginFrame(kFrameInterval); + BeginFrame(base::TimeDelta::FromMilliseconds(500)); + BeginFrame(kFrameInterval); + + ASSERT_EQ(ScrollOffset(0, 20), ScrollerOffset()); + EXPECT_TRUE(did_request_commit_); + + if (mutates_transform_tree) + EXPECT_EQ(ScrollOffset(0, 20), transform_node->scroll_offset); + else + EXPECT_EQ(ScrollOffset(0, 0), transform_node->scroll_offset); + EXPECT_EQ(mutates_transform_tree, transform_node->transform_changed); + EXPECT_EQ(mutates_transform_tree, + transform_node->needs_local_transform_update); + EXPECT_EQ(mutates_transform_tree, tree.needs_update()); + } +} + +// When scrolling a main-thread hit tested scroller with main thread reasons, +// we should update the scroll node but the transform tree shouldn't be +// mutated. Also ensure NeedsCommit is set. A nice additional benefit of scroll +// unification should be seamless upgrade to a full compositor scroll if a main +// thread reason is removed. +TEST_F(UnifiedScrollingTest, MainThreadReasonsScrollDoesntAffectTransform) { + CreateScroller( + MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects); + + TestUncompositedScrollingState(/*mutates_transform_tree=*/false); + + ASSERT_EQ(ScrollerNode()->main_thread_scrolling_reasons, + MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects); + TransformTree& tree = GetPropertyTrees()->transform_tree; + TransformNode* transform_node = tree.Node(ScrollerNode()->transform_id); + + // Removing the main thread reason bit should start mutating the transform + // tree. + { + ScrollerNode()->main_thread_scrolling_reasons = + MainThreadScrollingReason::kNotScrollingOnMain; + UpdateDrawProperties(host_impl_->active_tree()); + host_impl_->active_tree()->DidBecomeActive(); + + ScrollUpdate(Vector2d(0, 10)); + ASSERT_EQ(ScrollOffset(0, 30), ScrollerOffset()); + + // The transform node should now be updated by the scroll. + EXPECT_EQ(ScrollOffset(0, 30), transform_node->scroll_offset); + EXPECT_TRUE(transform_node->transform_changed); + EXPECT_TRUE(transform_node->needs_local_transform_update); + EXPECT_TRUE(tree.needs_update()); + } + + ScrollEnd(); +} + +// When scrolling an uncomposited scroller, we shouldn't modify the transform +// tree. If a scroller is promoted mid-scroll it should start mutating the +// transform tree. +TEST_F(UnifiedScrollingTest, UncompositedScrollerDoesntAffectTransform) { + CreateUncompositedScrollerAndNonFastScrollableRegion(); + + TestUncompositedScrollingState(/*mutates_transform_tree=*/false); + + ASSERT_FALSE(ScrollerNode()->is_composited); + TransformTree& tree = GetPropertyTrees()->transform_tree; + TransformNode* transform_node = tree.Node(ScrollerNode()->transform_id); + + // Marking the node as composited should start updating the transform tree. + { + ScrollerNode()->is_composited = true; + UpdateDrawProperties(host_impl_->active_tree()); + host_impl_->active_tree()->DidBecomeActive(); + + ScrollUpdate(Vector2d(0, 10)); + ASSERT_EQ(ScrollOffset(0, 30), ScrollerOffset()); + + // The transform node should now be updated by the scroll. + EXPECT_EQ(ScrollOffset(0, 30), transform_node->scroll_offset); + EXPECT_TRUE(transform_node->transform_changed); + EXPECT_TRUE(transform_node->needs_local_transform_update); + EXPECT_TRUE(tree.needs_update()); + } + + ScrollEnd(); +} + +// When scrolling a composited scroller that just happens to have needed a main +// thread hit test first, we should modify the transform tree as usual. +TEST_F(UnifiedScrollingTest, CompositedWithSquashedLayerMutatesTransform) { + CreateScroller(MainThreadScrollingReason::kNotScrollingOnMain); + CreateSuashingLayerCoveringWholeViewport(); + + TestUncompositedScrollingState(/*mutates_transform_tree=*/true); + + ScrollEnd(); +} + } // namespace } // namespace cc diff --git a/chromium/cc/trees/layer_tree_host_pixeltest_blending.cc b/chromium/cc/trees/layer_tree_host_pixeltest_blending.cc index b55a4b3b733..0a6809e778a 100644 --- a/chromium/cc/trees/layer_tree_host_pixeltest_blending.cc +++ b/chromium/cc/trees/layer_tree_host_pixeltest_blending.cc @@ -6,12 +6,13 @@ #include "base/stl_util.h" #include "build/build_config.h" -#include "cc/layers/picture_image_layer.h" #include "cc/layers/solid_color_layer.h" #include "cc/paint/paint_image.h" #include "cc/paint/paint_image_builder.h" #include "cc/paint/render_surface_filters.h" #include "cc/paint/skia_paint_canvas.h" +#include "cc/test/fake_content_layer_client.h" +#include "cc/test/fake_picture_layer.h" #include "cc/test/layer_tree_pixel_resource_test.h" #include "cc/test/pixel_comparator.h" #include "cc/test/test_layer_tree_frame_sink.h" @@ -118,23 +119,19 @@ class LayerTreeHostBlendingPixelTest scoped_refptr<Layer> CreateColorfulBackdropLayer(int width, int height) { sk_sp<SkSurface> backing_store = CreateColorfulSurface(width, height); - scoped_refptr<PictureImageLayer> layer = PictureImageLayer::Create(); + gfx::Size bounds(width, height); + backdrop_client_.set_bounds(bounds); + backdrop_client_.add_draw_image(backing_store->makeImageSnapshot(), + gfx::Point(), PaintFlags()); + scoped_refptr<FakePictureLayer> layer = + FakePictureLayer::Create(&backdrop_client_); layer->SetIsDrawable(true); - layer->SetBounds(gfx::Size(width, height)); - layer->SetImage(PaintImageBuilder::WithDefault() - .set_id(PaintImage::GetNextId()) - .set_image(backing_store->makeImageSnapshot(), - PaintImage::GetNextContentId()) - .TakePaintImage(), - SkMatrix::I(), false); + layer->SetBounds(bounds); return layer; } void SetupMaskLayer(scoped_refptr<Layer> layer) { gfx::Size bounds = layer->bounds(); - scoped_refptr<PictureImageLayer> mask = PictureImageLayer::Create(); - mask->SetIsDrawable(true); - mask->SetBounds(bounds); sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(bounds.width(), bounds.height()); @@ -146,12 +143,15 @@ class LayerTreeHostBlendingPixelTest // cover the right half of it canvas->drawRect( SkRect::MakeXYWH(1, 0, bounds.width() - 1, bounds.height()), paint); - mask->SetImage(PaintImageBuilder::WithDefault() - .set_id(PaintImage::GetNextId()) - .set_image(surface->makeImageSnapshot(), - PaintImage::GetNextContentId()) - .TakePaintImage(), - SkMatrix::I(), false); + + mask_client_.set_bounds(bounds); + mask_client_.add_draw_image(surface->makeImageSnapshot(), gfx::Point(), + PaintFlags()); + + scoped_refptr<FakePictureLayer> mask = + FakePictureLayer::Create(&mask_client_); + mask->SetIsDrawable(true); + mask->SetBounds(bounds); layer->SetMaskLayer(mask); } @@ -254,6 +254,8 @@ class LayerTreeHostBlendingPixelTest bool force_antialiasing_; bool force_blending_with_shaders_; + FakeContentLayerClient mask_client_; + FakeContentLayerClient backdrop_client_; SkColor misc_opaque_color_ = 0xffc86464; }; diff --git a/chromium/cc/trees/layer_tree_host_pixeltest_filters.cc b/chromium/cc/trees/layer_tree_host_pixeltest_filters.cc index c93b84e3271..4042e97367c 100644 --- a/chromium/cc/trees/layer_tree_host_pixeltest_filters.cc +++ b/chromium/cc/trees/layer_tree_host_pixeltest_filters.cc @@ -309,55 +309,6 @@ TEST_P(LayerTreeHostFiltersPixelTest, BackdropFilterBlurOutsets) { base::FilePath(FILE_PATH_LITERAL("backdrop_filter_blur_outsets.png"))); } -class LayerTreeHostImageFiltersPixelTestLayerList - : public LayerTreeHostFiltersPixelTest { - public: - LayerTreeHostImageFiltersPixelTestLayerList() { SetUseLayerLists(); } - - void SetupTree() override { - SetInitialRootBounds(gfx::Size(200, 200)); - LayerTreePixelTest::SetupTree(); - - Layer* root = layer_tree_host()->root_layer(); - scoped_refptr<SolidColorLayer> background = - CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorYELLOW); - CopyProperties(root, background.get()); - root->AddChild(background); - - scoped_refptr<SolidColorLayer> foreground = - CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorRED); - CopyProperties(root, foreground.get()); - root->AddChild(foreground); - - EffectNode& effect_node = CreateEffectNode(foreground.get()); - float matrix[20] = {0}; - // This filter does a red-blue swap, so the foreground becomes blue. - matrix[2] = matrix[6] = matrix[10] = matrix[18] = 1.0f; - // Set up a crop rect to filter the bottom 200x100 pixels of the foreground. - SkImageFilter::CropRect crop_rect(SkRect::MakeXYWH(0, 100, 200, 100)); - FilterOperations filters; - filters.Append(FilterOperation::CreateReferenceFilter( - sk_make_sp<ColorFilterPaintFilter>(SkColorFilters::Matrix(matrix), - nullptr, &crop_rect))); - - effect_node.filters = filters; - effect_node.render_surface_reason = RenderSurfaceReason::kFilter; - - // Move the filters origin up by 100 pixels so the crop rect is applied - // only to the top 100 pixels, not the bottom. - effect_node.filters_origin = gfx::PointF(0.0f, -100.0f); - } -}; - -INSTANTIATE_TEST_SUITE_P(All, - LayerTreeHostImageFiltersPixelTestLayerList, - ::testing::ValuesIn(kRendererTypes)); - -TEST_P(LayerTreeHostImageFiltersPixelTestLayerList, NonZeroOrigin) { - RunPixelTestWithLayerList( - base::FilePath(FILE_PATH_LITERAL("blue_yellow.png"))); -} - class LayerTreeHostBlurFiltersPixelTestGPULayerList : public LayerTreeHostFiltersPixelTest { public: diff --git a/chromium/cc/trees/layer_tree_host_pixeltest_masks.cc b/chromium/cc/trees/layer_tree_host_pixeltest_masks.cc index 7e39b785622..702d4e5dbb7 100644 --- a/chromium/cc/trees/layer_tree_host_pixeltest_masks.cc +++ b/chromium/cc/trees/layer_tree_host_pixeltest_masks.cc @@ -7,13 +7,13 @@ #include "base/stl_util.h" #include "build/build_config.h" #include "cc/layers/content_layer_client.h" -#include "cc/layers/picture_image_layer.h" #include "cc/layers/picture_layer.h" #include "cc/layers/solid_color_layer.h" #include "cc/paint/paint_flags.h" #include "cc/paint/paint_image.h" #include "cc/paint/paint_image_builder.h" #include "cc/paint/paint_op_buffer.h" +#include "cc/test/fake_content_layer_client.h" #include "cc/test/fake_picture_layer.h" #include "cc/test/layer_tree_pixel_resource_test.h" #include "cc/test/pixel_comparator.h" @@ -318,22 +318,20 @@ TEST_P(LayerTreeHostMaskPixelTestWithLayerList, MaskWithEffectDifferentSize) { } TEST_P(LayerTreeHostMaskPixelTestWithLayerList, ImageMaskWithEffect) { - MaskContentLayerClient client(mask_bounds_); - scoped_refptr<PictureImageLayer> mask_layer = PictureImageLayer::Create(); + MaskContentLayerClient mask_client(mask_bounds_); sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(50, 50); SkCanvas* canvas = surface->getCanvas(); scoped_refptr<DisplayItemList> mask_display_list = - client.PaintContentsToDisplayList( + mask_client.PaintContentsToDisplayList( ContentLayerClient::PAINTING_BEHAVIOR_NORMAL); mask_display_list->Raster(canvas); - mask_layer->SetImage(PaintImageBuilder::WithDefault() - .set_id(PaintImage::GetNextId()) - .set_image(surface->makeImageSnapshot(), - PaintImage::GetNextContentId()) - .TakePaintImage(), - SkMatrix::I(), false); - mask_layer_ = mask_layer; + + FakeContentLayerClient layer_client; + layer_client.set_bounds(mask_bounds_); + layer_client.add_draw_image(surface->makeImageSnapshot(), gfx::Point(), + PaintFlags()); + mask_layer_ = FakePictureLayer::Create(&layer_client); pixel_comparator_ = std::make_unique<FuzzyPixelOffByOneComparator>(true /* discard_alpha */); @@ -350,10 +348,6 @@ TEST_P(LayerTreeHostMasksPixelTest, ImageMaskOfLayer) { gfx::Size mask_bounds(50, 50); - scoped_refptr<PictureImageLayer> mask = PictureImageLayer::Create(); - mask->SetIsDrawable(true); - mask->SetBounds(mask_bounds); - sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(50, 50); SkCanvas* canvas = surface->getCanvas(); MaskContentLayerClient client(mask_bounds); @@ -361,12 +355,14 @@ TEST_P(LayerTreeHostMasksPixelTest, ImageMaskOfLayer) { client.PaintContentsToDisplayList( ContentLayerClient::PAINTING_BEHAVIOR_NORMAL); mask_display_list->Raster(canvas); - mask->SetImage(PaintImageBuilder::WithDefault() - .set_id(PaintImage::GetNextId()) - .set_image(surface->makeImageSnapshot(), - PaintImage::GetNextContentId()) - .TakePaintImage(), - SkMatrix::I(), false); + + FakeContentLayerClient mask_client; + mask_client.set_bounds(mask_bounds); + mask_client.add_draw_image(surface->makeImageSnapshot(), gfx::Point(), + PaintFlags()); + scoped_refptr<FakePictureLayer> mask = FakePictureLayer::Create(&mask_client); + mask->SetIsDrawable(true); + mask->SetBounds(mask_bounds); scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder( gfx::Rect(25, 25, 50, 50), kCSSGreen, 1, SK_ColorBLACK); diff --git a/chromium/cc/trees/layer_tree_host_pixeltest_synchronous.cc b/chromium/cc/trees/layer_tree_host_pixeltest_synchronous.cc index 2739d9880bb..34d9ef117a4 100644 --- a/chromium/cc/trees/layer_tree_host_pixeltest_synchronous.cc +++ b/chromium/cc/trees/layer_tree_host_pixeltest_synchronous.cc @@ -4,7 +4,6 @@ #include "build/build_config.h" #include "cc/layers/content_layer_client.h" -#include "cc/layers/picture_image_layer.h" #include "cc/layers/picture_layer.h" #include "cc/layers/solid_color_layer.h" #include "cc/test/fake_content_layer_client.h" diff --git a/chromium/cc/trees/layer_tree_host_unittest.cc b/chromium/cc/trees/layer_tree_host_unittest.cc index edbee8ea336..2d94507a792 100644 --- a/chromium/cc/trees/layer_tree_host_unittest.cc +++ b/chromium/cc/trees/layer_tree_host_unittest.cc @@ -52,7 +52,6 @@ #include "cc/test/test_layer_tree_frame_sink.h" #include "cc/trees/clip_node.h" #include "cc/trees/effect_node.h" -#include "cc/trees/frame_rate_counter.h" #include "cc/trees/layer_tree_host_impl.h" #include "cc/trees/layer_tree_impl.h" #include "cc/trees/scroll_and_scale_set.h" @@ -6187,9 +6186,9 @@ class LayerTreeHostTestSwapPromiseDuringCommit : public LayerTreeHostTest { &set_needs_commit_count, &set_needs_redraw_count)); layer_tree_host()->QueueSwapPromise(std::move(swap_promise)); - // Queueing a swap promise from DidBeginMainFrame should cause a + // Queueing a swap promise from DidBeginMainFrame should not cause a // subsequent main frame to be scheduled. - EXPECT_EQ(1, set_needs_commit_count); + EXPECT_EQ(0, set_needs_commit_count); } EndTest(); @@ -8902,28 +8901,11 @@ class LayerTreeHostCustomThrougputTrackerTest : public LayerTreeHostTest { } void NotifyThroughputTrackerResults(CustomTrackerResults results) override { + // Check that data for kSequenceId is captured. Ideally, we should get + // 2 frame_expected and 2 frame_produced. But on slow bots, it is difficult + // to infer the correct numbers. Both frame_expected and frame_produced + // could drop to 1 (or even below). So no sanity check on data itself. ASSERT_TRUE(base::Contains(results, kSequenceId)); - const auto& throughput = results[kSequenceId]; - // Frame 3 and 4 are counted. See the sequence in DidCommit comment for - // normal case that expects 2 for both frames_expected and frames_produced. - // - // However, on slow bots, things could be different. - // - Begin frame could be skipped but still counted as expected frames, - // - // e(5,5)b(8)B(0,8)E(8)s(3)S(8)e(8,8)b(11) - // B(8,11)E(11)ts(4)S(11)e(11,11)P(3)e(14,14)P(4) - // - // B(0, 8) and B(8, 11) make frame_expected to be 4, more than 2 expected - // by test. - // - // - Finish before frame 4 is presented in multi-thread mode. - // - // e(3,3)b(4)B(0,4)E(4)s(2)e(4,4)b(6)B(4,6)E(6)s(3)S(4)e(6,6) - // P(2)e(7,7)P(3) - // - // Only P(3) is counted thus frames_produced is 1. - EXPECT_GE(throughput.frames_expected, 2u); - EXPECT_GE(throughput.frames_produced, 1u); EndTest(); } @@ -8931,5 +8913,112 @@ class LayerTreeHostCustomThrougputTrackerTest : public LayerTreeHostTest { SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostCustomThrougputTrackerTest); +// Confirm that DelegatedInkMetadata set on the LTH propagates to the +// CompositorFrameMetadata and RenderFrameMetadata, and then both are correctly +// reset when another frame is drawn without DelegatedInkMetadata. +class LayerTreeHostTestDelegatedInkMetadataOnAndOff + : public LayerTreeHostTest, + public RenderFrameMetadataObserver { + public: + // Provides a wrapper which can be passed to LayerTreeHost, but just forwards + // to the test class. + class ForwardingRenderFrameMetadataObserver + : public RenderFrameMetadataObserver { + public: + explicit ForwardingRenderFrameMetadataObserver( + RenderFrameMetadataObserver* target) + : target_(target) {} + + // RenderFrameMetadataObserver implementation. + void BindToCurrentThread() override { target_->BindToCurrentThread(); } + void OnRenderFrameSubmission( + const RenderFrameMetadata& render_frame_metadata, + viz::CompositorFrameMetadata* compositor_frame_metadata, + bool force_send) override { + target_->OnRenderFrameSubmission(render_frame_metadata, + compositor_frame_metadata, force_send); + } + + private: + RenderFrameMetadataObserver* target_ = nullptr; + }; + + void BeginTest() override { + // Set up a basic render frame observer for the LTH/LTHI to forward to. + layer_tree_host()->SetRenderFrameObserver( + std::make_unique<ForwardingRenderFrameMetadataObserver>(this)); + + // Setting up a basic frame that can be redrawn. + layer_tree_host()->SetViewportRectAndScale(gfx::Rect(10, 10), 1.f, + viz::LocalSurfaceIdAllocation()); + layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10)); + layer_ = FakePictureLayer::Create(&client_); + layer_tree_host()->root_layer()->AddChild(layer_); + client_.set_bounds(layer_->bounds()); + + // Values chosen arbitrarily + SkColor color = SK_ColorDKGRAY; + double diameter = 1.000002; + gfx::PointF point = gfx::PointF(135, 45); + gfx::RectF area = gfx::RectF(173, 438); + base::TimeTicks timestamp = base::TimeTicks::Now(); + + expected_metadata_ = + viz::DelegatedInkMetadata(point, diameter, color, timestamp, area); + layer_tree_host()->SetDelegatedInkMetadata( + std::make_unique<viz::DelegatedInkMetadata>( + expected_metadata_.value())); + } + + void DidCommitAndDrawFrame() override { + // Cause a redraw to occur. + layer_->SetNeedsDisplay(); + } + + void DrawLayersOnThread(LayerTreeHostImpl* impl) override { + if (expected_metadata_.has_value()) { + // Now try again with no metadata to confirm everything is cleared out. + expected_metadata_.reset(); + } + } + + void ExpectMetadata(bool had_delegated_ink_metadata, + viz::DelegatedInkMetadata* actual_metadata) { + if (expected_metadata_.has_value()) { + EXPECT_TRUE(had_delegated_ink_metadata); + EXPECT_TRUE(actual_metadata); + EXPECT_EQ(expected_metadata_->point(), actual_metadata->point()); + EXPECT_EQ(expected_metadata_->color(), actual_metadata->color()); + EXPECT_EQ(expected_metadata_->diameter(), actual_metadata->diameter()); + EXPECT_EQ(expected_metadata_->presentation_area(), + actual_metadata->presentation_area()); + EXPECT_EQ(expected_metadata_->timestamp(), actual_metadata->timestamp()); + } else { + EXPECT_FALSE(had_delegated_ink_metadata); + EXPECT_FALSE(actual_metadata); + EndTest(); + } + } + + void AfterTest() override {} + + // RenderFrameMetadataObserver implementation. + void BindToCurrentThread() override {} + void OnRenderFrameSubmission( + const RenderFrameMetadata& render_frame_metadata, + viz::CompositorFrameMetadata* compositor_frame_metadata, + bool force_send) override { + ExpectMetadata(render_frame_metadata.has_delegated_ink_metadata, + compositor_frame_metadata->delegated_ink_metadata.get()); + } + + private: + base::Optional<viz::DelegatedInkMetadata> expected_metadata_; + FakeContentLayerClient client_; + scoped_refptr<Layer> layer_; +}; + +SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDelegatedInkMetadataOnAndOff); + } // namespace } // namespace cc diff --git a/chromium/cc/trees/layer_tree_host_unittest_copyrequest.cc b/chromium/cc/trees/layer_tree_host_unittest_copyrequest.cc index bb64e9ef4a4..7a188881491 100644 --- a/chromium/cc/trees/layer_tree_host_unittest_copyrequest.cc +++ b/chromium/cc/trees/layer_tree_host_unittest_copyrequest.cc @@ -10,6 +10,7 @@ #include "base/threading/thread_task_runner_handle.h" #include "base/time/time.h" #include "cc/layers/effect_tree_layer_list_iterator.h" +#include "cc/test/cc_test_suite.h" #include "cc/test/fake_content_layer_client.h" #include "cc/test/fake_picture_layer.h" #include "cc/test/layer_tree_test.h" @@ -309,13 +310,19 @@ class LayerTreeHostCopyRequestTestLayerDestroyed base::BindOnce( &LayerTreeHostCopyRequestTestLayerDestroyed::CopyOutputCallback, base::Unretained(this)))); + // We expect that the RequestCopyOfOutput won't yet return results until + // the main is destroyed. So we RunUntilIdle to ensure no PostTask is + // currently queued to return the result. + CCTestSuite::RunUntilIdle(); EXPECT_EQ(0, callback_count_); // Destroy the main thread layer right away. main_destroyed_->RemoveFromParent(); main_destroyed_.reset(); - // Should callback with a NULL bitmap. + // Should callback with a NULL bitmap, result will be in a PostTask so + // RunUntilIdle(). + CCTestSuite::RunUntilIdle(); EXPECT_EQ(1, callback_count_); // Prevent drawing so we can't make a copy of the impl_destroyed layer. @@ -350,7 +357,6 @@ class LayerTreeHostCopyRequestTestLayerDestroyed } void CopyOutputCallback(std::unique_ptr<viz::CopyOutputResult> result) { - EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread()); EXPECT_TRUE(result->IsEmpty()); ++callback_count_; } diff --git a/chromium/cc/trees/layer_tree_host_unittest_scroll.cc b/chromium/cc/trees/layer_tree_host_unittest_scroll.cc index a5f7b6e522a..3a95b182bf0 100644 --- a/chromium/cc/trees/layer_tree_host_unittest_scroll.cc +++ b/chromium/cc/trees/layer_tree_host_unittest_scroll.cc @@ -10,8 +10,10 @@ #include "base/single_thread_task_runner.h" #include "base/stl_util.h" #include "base/threading/thread_task_runner_handle.h" +#include "build/build_config.h" #include "cc/animation/animation_host.h" #include "cc/base/completion_event.h" +#include "cc/base/features.h" #include "cc/input/main_thread_scrolling_reason.h" #include "cc/input/scroll_elasticity_helper.h" #include "cc/layers/layer.h" @@ -42,11 +44,14 @@ using ::testing::Mock; namespace cc { namespace { -std::unique_ptr<ScrollState> BeginState(const gfx::Point& point) { +std::unique_ptr<ScrollState> BeginState(const gfx::Point& point, + const gfx::Vector2dF& delta_hint) { ScrollStateData scroll_state_data; scroll_state_data.is_beginning = true; scroll_state_data.position_x = point.x(); scroll_state_data.position_y = point.y(); + scroll_state_data.delta_x_hint = delta_hint.x(); + scroll_state_data.delta_y_hint = delta_hint.y(); std::unique_ptr<ScrollState> scroll_state(new ScrollState(scroll_state_data)); return scroll_state; } @@ -685,8 +690,9 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest { gfx::Point scroll_point = gfx::ToCeiledPoint( gfx::PointF(-0.5f, -0.5f) + GetTransformNode(expected_scroll_layer_impl)->post_translation); - InputHandler::ScrollStatus status = impl->ScrollBegin( - BeginState(scroll_point).get(), ui::ScrollInputType::kTouchscreen); + InputHandler::ScrollStatus status = + impl->ScrollBegin(BeginState(scroll_point, scroll_amount_).get(), + ui::ScrollInputType::kTouchscreen); EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); impl->ScrollUpdate(UpdateState(gfx::Point(), scroll_amount_).get()); auto* scrolling_node = impl->CurrentlyScrollingNode(); @@ -708,8 +714,9 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest { gfx::Point scroll_point = gfx::ToCeiledPoint( gfx::PointF(0.5f, 0.5f) + GetTransformNode(expected_scroll_layer_impl)->post_translation); - InputHandler::ScrollStatus status = impl->ScrollBegin( - BeginState(scroll_point).get(), ui::ScrollInputType::kWheel); + InputHandler::ScrollStatus status = + impl->ScrollBegin(BeginState(scroll_point, scroll_amount_).get(), + ui::ScrollInputType::kWheel); EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); impl->ScrollUpdate(UpdateState(gfx::Point(), scroll_amount_).get()); impl->ScrollEnd(); @@ -1058,6 +1065,116 @@ class LayerTreeHostScrollTestImplOnlyScroll : public LayerTreeHostScrollTest { // This tests scrolling on the impl side which is only possible with a thread. MULTI_THREAD_TEST_F(LayerTreeHostScrollTestImplOnlyScroll); +// TODO(crbug.com/574283): Mac currently doesn't support smooth scrolling wheel +// events. +#if !defined(OS_MACOSX) +// This test simulates scrolling on the impl thread such that it starts a scroll +// animation. It ensures that RequestScrollAnimationEndNotification() correctly +// notifies the callback after the animation ends. +class SmoothScrollAnimationEndNotification : public LayerTreeHostScrollTest { + public: + SmoothScrollAnimationEndNotification() = default; + + void InitializeSettings(LayerTreeSettings* settings) override { + LayerTreeHostScrollTest::InitializeSettings(settings); + settings->enable_smooth_scroll = true; + } + + void SetupTree() override { + LayerTreeHostScrollTest::SetupTree(); + + Layer* root_layer = layer_tree_host()->root_layer(); + Layer* root_scroll_layer = + layer_tree_host()->OuterViewportScrollLayerForTesting(); + + child_layer_ = Layer::Create(); + child_layer_->SetElementId( + LayerIdToElementIdForTesting(child_layer_->id())); + child_layer_->SetBounds(gfx::Size(110, 110)); + + child_layer_->SetIsDrawable(true); + child_layer_->SetHitTestable(true); + child_layer_->SetElementId( + LayerIdToElementIdForTesting(child_layer_->id())); + child_layer_->SetBounds(root_scroll_layer->bounds()); + root_layer->AddChild(child_layer_); + + CopyProperties(root_scroll_layer, child_layer_.get()); + CreateTransformNode(child_layer_.get()); + CreateScrollNode(child_layer_.get(), root_layer->bounds()); + } + + void BeginTest() override { PostSetNeedsCommitToMainThread(); } + + void WillCommit() override { + // Keep the test committing (otherwise the early out for no update + // will stall the test). + if (layer_tree_host()->SourceFrameNumber() < 2) { + layer_tree_host()->SetNeedsCommit(); + } + } + + void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override { + if (host_impl->active_tree()->source_frame_number() < 0) + return; + + if (host_impl->active_tree()->source_frame_number() == 0) { + const gfx::Point scroll_point(10, 10); + const gfx::Vector2dF scroll_amount(350, -350); + auto scroll_state = BeginState(scroll_point, scroll_amount); + scroll_state->data()->delta_granularity = + ui::ScrollGranularity::kScrollByPixel; + InputHandler::ScrollStatus status = host_impl->ScrollBegin( + scroll_state.get(), ui::ScrollInputType::kWheel); + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + scroll_state = UpdateState(scroll_point, scroll_amount); + scroll_state->data()->delta_granularity = + ui::ScrollGranularity::kScrollByPixel; + host_impl->ScrollUpdate(scroll_state.get()); + + EXPECT_TRUE( + !!host_impl->mutator_host()->ImplOnlyScrollAnimatingElement()); + } else if (!scroll_end_requested_) { + host_impl->ScrollEnd(false); + scroll_end_requested_ = true; + } + PostSetNeedsCommitToMainThread(); + } + + void UpdateLayerTreeHost() override { + if (scroll_animation_started_) + return; + + if (layer_tree_host()->HasCompositorDrivenScrollAnimationForTesting()) { + scroll_animation_started_ = true; + layer_tree_host()->RequestScrollAnimationEndNotification( + base::BindOnce(&SmoothScrollAnimationEndNotification::OnScrollEnd, + base::Unretained(this))); + } + } + + void AfterTest() override { + EXPECT_TRUE(scroll_end_requested_); + EXPECT_TRUE(scroll_animation_started_); + EXPECT_TRUE(scroll_animation_ended_); + } + + private: + void OnScrollEnd() { + scroll_animation_ended_ = true; + EndTest(); + } + + scoped_refptr<Layer> child_layer_; + + bool scroll_end_requested_ = false; + bool scroll_animation_started_ = false; + bool scroll_animation_ended_ = false; +}; + +MULTI_THREAD_TEST_F(SmoothScrollAnimationEndNotification); +#endif // !defined(OS_MACOSX) + void DoGestureScroll(LayerTreeHostImpl* host_impl, const scoped_refptr<Layer>& scroller, gfx::Vector2dF offset) { @@ -1354,12 +1471,13 @@ class LayerTreeHostScrollTestScrollZeroMaxScrollOffset void SetupTree() override { LayerTreeHostScrollTest::SetupTree(); - // Add a sub-scroller to test TryScroll against. The outer viewport scroll + // Add a sub-scroller to test ScrollBegin against. The outer viewport scroll // will be latched to for scrolling even if it doesn't have any scroll // extent in the given direction to support overscroll actions. scroller_ = Layer::Create(); scroller_->SetIsDrawable(true); scroller_->SetHitTestable(true); + scroller_->SetBounds(gfx::Size(200, 200)); scroller_->SetElementId(LayerIdToElementIdForTesting(scroller_->id())); CopyProperties(layer_tree_host()->OuterViewportScrollLayerForTesting(), scroller_.get()); @@ -1369,61 +1487,91 @@ class LayerTreeHostScrollTestScrollZeroMaxScrollOffset layer_tree_host()->root_layer()->AddChild(scroller_.get()); } - void BeginTest() override { PostSetNeedsCommitToMainThread(); } + void BeginTest() override { NextStep(); } + + void NextStep() { + if (TestEnded()) + return; + + ++cur_step_; - void UpdateLayerTreeHost() override { ScrollTree& scroll_tree = layer_tree_host()->property_trees()->scroll_tree; ScrollNode* scroll_node = scroll_tree.Node(scroller_->scroll_tree_index()); - switch (layer_tree_host()->SourceFrameNumber()) { - case 0: + switch (cur_step_) { + case 1: // Set max_scroll_offset = (100, 100). scroll_node->bounds = scroll_node->container_bounds; scroll_node->bounds.Enlarge(100, 100); break; - case 1: + case 2: // Set max_scroll_offset = (0, 0). scroll_node->bounds = scroll_node->container_bounds; break; - case 2: + case 3: // Set max_scroll_offset = (-1, -1). scroll_node->bounds = gfx::Size(); break; } + + layer_tree_host()->SetNeedsCommit(); } void DrawLayersOnThread(LayerTreeHostImpl* impl) override { + if (TestEnded()) + return; + ScrollTree& scroll_tree = impl->active_tree()->property_trees()->scroll_tree; ScrollNode* scroll_node = scroll_tree.Node(scroller_->scroll_tree_index()); + + ScrollStateData scroll_state_data; + scroll_state_data.is_beginning = true; + // The position has to be at (0, 0) since the viewport in this test has + // bounds (1, 1). + scroll_state_data.position_x = 0; + scroll_state_data.position_y = 0; + scroll_state_data.delta_x_hint = 10; + scroll_state_data.delta_y_hint = 10; + scroll_state_data.is_direct_manipulation = true; + + ScrollState scroll_state(scroll_state_data); InputHandler::ScrollStatus status = - impl->TryScroll(scroll_tree, scroll_node); - switch (impl->active_tree()->source_frame_number()) { - case 0: - EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread) - << "In Frame 0"; - EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, - status.main_thread_scrolling_reasons) - << "In Frame 0"; - PostSetNeedsCommitToMainThread(); - break; + impl->ScrollBegin(&scroll_state, ui::ScrollInputType::kTouchscreen); + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread) + << "In Frame " << impl->active_tree()->source_frame_number(); + + switch (cur_step_) { case 1: - EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread) << "In Frame 1"; - EXPECT_EQ(MainThreadScrollingReason::kNotScrollable, - status.main_thread_scrolling_reasons) - << "In Frame 1"; - PostSetNeedsCommitToMainThread(); + // Since the scroller has scroll extend and is scrollable, we should + // have targeted it. + EXPECT_EQ(scroll_node, impl->CurrentlyScrollingNode()) << "In Frame 0"; break; case 2: - EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread) << "In Frame 2"; - EXPECT_EQ(MainThreadScrollingReason::kNotScrollable, - status.main_thread_scrolling_reasons) + // Since the max_scroll_offset is (0, 0) - we shouldn't target it and + // we should instead bubble up to the viewport. + EXPECT_EQ(impl->OuterViewportScrollNode(), + impl->CurrentlyScrollingNode()) + << "In Frame 1"; + break; + case 3: + // Since the max_scroll_offset is (-1, -1) - we shouldn't target it and + // we should instead bubble up to the viewport. + EXPECT_EQ(impl->OuterViewportScrollNode(), + impl->CurrentlyScrollingNode()) << "In Frame 2"; EndTest(); break; } + impl->ScrollEnd(); + MainThreadTaskRunner()->PostTask( + FROM_HERE, + base::BindOnce( + &LayerTreeHostScrollTestScrollZeroMaxScrollOffset::NextStep, + base::Unretained(this))); } private: + int cur_step_ = 0; scoped_refptr<Layer> scroller_; }; @@ -1453,14 +1601,23 @@ class LayerTreeHostScrollTestScrollNonDrawnLayer // checking whether the screen space point is inside the non-fast // scrollable region. InputHandler::ScrollStatus status = impl->ScrollBegin( - BeginState(gfx::Point(0, 0)).get(), ui::ScrollInputType::kTouchscreen); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, - status.main_thread_scrolling_reasons); + BeginState(gfx::Point(0, 0), gfx::Vector2dF(0, 1)).get(), + ui::ScrollInputType::kTouchscreen); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_TRUE(status.needs_main_thread_hit_test); + impl->ScrollEnd(); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, + status.main_thread_scrolling_reasons); + } - status = impl->ScrollBegin(BeginState(gfx::Point(21, 21)).get(), - ui::ScrollInputType::kTouchscreen); + status = impl->ScrollBegin( + BeginState(gfx::Point(21, 21), gfx::Vector2dF(0, 1)).get(), + ui::ScrollInputType::kTouchscreen); EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, status.main_thread_scrolling_reasons); @@ -1481,36 +1638,88 @@ class LayerTreeHostScrollTestImplScrollUnderMainThreadScrollingParent void SetupTree() override { LayerTreeHostScrollTest::SetupTree(); - GetScrollNode(layer_tree_host()->InnerViewportScrollLayerForTesting()) + GetScrollNode(layer_tree_host()->OuterViewportScrollLayerForTesting()) ->main_thread_scrolling_reasons = - MainThreadScrollingReason::kScrollbarScrolling; + MainThreadScrollingReason::kThreadedScrollingDisabled; + + scroller_ = Layer::Create(); + scroller_->SetIsDrawable(true); + scroller_->SetHitTestable(true); + scroller_->SetBounds(gfx::Size(200, 200)); + scroller_->SetElementId(LayerIdToElementIdForTesting(scroller_->id())); + CopyProperties(layer_tree_host()->OuterViewportScrollLayerForTesting(), + scroller_.get()); + CreateTransformNode(scroller_.get()); + CreateScrollNode(scroller_.get(), + layer_tree_host()->root_layer()->bounds()); + layer_tree_host()->root_layer()->AddChild(scroller_.get()); } void DrawLayersOnThread(LayerTreeHostImpl* impl) override { - LayerImpl* inner_scroll_layer = - impl->active_tree()->InnerViewportScrollLayerForTesting(); - LayerImpl* outer_scroll_layer = - impl->active_tree()->OuterViewportScrollLayerForTesting(); - ScrollTree& scroll_tree = impl->active_tree()->property_trees()->scroll_tree; - ScrollNode* inner_scroll_node = - scroll_tree.Node(inner_scroll_layer->scroll_tree_index()); - ScrollNode* outer_scroll_node = - scroll_tree.Node(outer_scroll_layer->scroll_tree_index()); + ScrollNode* scroller_scroll_node = + scroll_tree.Node(scroller_->scroll_tree_index()); + + ScrollStateData scroll_state_data; + scroll_state_data.is_beginning = true; + // To hit the scroller, the position has to be at (0, 0) since the viewport + // in this test has bounds (1, 1) and would otherwise clip the hit test. + scroll_state_data.position_x = 0; + scroll_state_data.position_y = 0; + scroll_state_data.delta_x_hint = 10; + scroll_state_data.delta_y_hint = 10; + scroll_state_data.is_direct_manipulation = true; + ScrollState scroll_state(scroll_state_data); + + // Scroll hitting the scroller layer. + { + InputHandler::ScrollStatus status = + impl->ScrollBegin(&scroll_state, ui::ScrollInputType::kTouchscreen); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(impl->CurrentlyScrollingNode(), scroller_scroll_node); + EXPECT_FALSE(status.needs_main_thread_hit_test); + } else { + // Despite the fact that we hit the scroller, which has no main thread + // scrolling reason, we still must fallback to main thread scrolling due + // to the fact that it has a main thread scrolling ancestor. + EXPECT_EQ(impl->CurrentlyScrollingNode(), nullptr); + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kThreadedScrollingDisabled, + status.main_thread_scrolling_reasons); + } + impl->ScrollEnd(); + } - InputHandler::ScrollStatus status = - impl->TryScroll(scroll_tree, inner_scroll_node); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kScrollbarScrolling, - status.main_thread_scrolling_reasons); + // Scroll hitting the viewport layer. + { + // A hit test outside the viewport should fallback to scrolling the + // viewport. + scroll_state.data()->position_y = 1000; + + InputHandler::ScrollStatus status = + impl->ScrollBegin(&scroll_state, ui::ScrollInputType::kTouchscreen); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + EXPECT_EQ(impl->CurrentlyScrollingNode(), + impl->OuterViewportScrollNode()); + } else { + // Since the viewport has a main thread scrolling reason, this + // too should fallback to the main thread. + EXPECT_EQ(impl->CurrentlyScrollingNode(), nullptr); + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kThreadedScrollingDisabled, + status.main_thread_scrolling_reasons); + } + impl->ScrollEnd(); + } - status = impl->TryScroll(scroll_tree, outer_scroll_node); - EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, - status.main_thread_scrolling_reasons); EndTest(); } + + private: + scoped_refptr<Layer> scroller_; }; SINGLE_AND_MULTI_THREAD_TEST_F( @@ -2422,27 +2631,28 @@ class NonScrollingNonFastScrollableRegion : public LayerTreeHostScrollTest { void SetupTree() override { SetInitialRootBounds(gfx::Size(800, 600)); LayerTreeHostScrollTest::SetupTree(); - Layer* root = layer_tree_host()->root_layer(); - fake_content_layer_client_.set_bounds(root->bounds()); + Layer* outer_scroll = + layer_tree_host()->OuterViewportScrollLayerForTesting(); + fake_content_layer_client_.set_bounds(outer_scroll->bounds()); bottom_ = FakePictureLayer::Create(&fake_content_layer_client_); bottom_->SetElementId(LayerIdToElementIdForTesting(bottom_->id())); bottom_->SetBounds(gfx::Size(100, 100)); bottom_->SetNonFastScrollableRegion(Region(gfx::Rect(50, 50, 50, 50))); bottom_->SetHitTestable(true); - CopyProperties(root, bottom_.get()); - root->AddChild(bottom_); + CopyProperties(outer_scroll, bottom_.get()); + outer_scroll->AddChild(bottom_); middle_scrollable_ = FakePictureLayer::Create(&fake_content_layer_client_); middle_scrollable_->SetElementId( LayerIdToElementIdForTesting(middle_scrollable_->id())); - middle_scrollable_->SetBounds(gfx::Size(100, 100)); + middle_scrollable_->SetBounds(gfx::Size(100, 200)); middle_scrollable_->SetIsDrawable(true); middle_scrollable_->SetHitTestable(true); CopyProperties(bottom_.get(), middle_scrollable_.get()); CreateTransformNode(middle_scrollable_.get()); - CreateScrollNode(middle_scrollable_.get(), gfx::Size(100, 200)); - root->AddChild(middle_scrollable_); + CreateScrollNode(middle_scrollable_.get(), gfx::Size(100, 100)); + outer_scroll->AddChild(middle_scrollable_); top_ = FakePictureLayer::Create(&fake_content_layer_client_); top_->SetElementId(LayerIdToElementIdForTesting(top_->id())); @@ -2450,7 +2660,7 @@ class NonScrollingNonFastScrollableRegion : public LayerTreeHostScrollTest { top_->SetNonFastScrollableRegion(Region(gfx::Rect(0, 0, 50, 50))); top_->SetHitTestable(true); CopyProperties(middle_scrollable_.get(), top_.get()); - root->AddChild(top_); + outer_scroll->AddChild(top_); } void BeginTest() override { PostSetNeedsCommitToMainThread(); } @@ -2459,35 +2669,70 @@ class NonScrollingNonFastScrollableRegion : public LayerTreeHostScrollTest { if (TestEnded()) return; - // The top-left hit should immediately hit the top layer's non-fast region - // which forces main-thread scrolling. - auto top_left_status = - impl->ScrollBegin(BeginState(gfx::Point(20, 20)).get(), - ui::ScrollInputType::kTouchscreen); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, top_left_status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, - top_left_status.main_thread_scrolling_reasons); - - // The top-right hit should hit the top layer but not the non-fast region so - // the scroll should continue to scroll on the impl. - InputHandler::ScrollStatus top_right_status = - impl->ScrollBegin(BeginState(gfx::Point(80, 20)).get(), - ui::ScrollInputType::kTouchscreen); - EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, top_right_status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, - top_right_status.main_thread_scrolling_reasons); - impl->ScrollEnd(); + ScrollNode* scroll_node = + impl->active_tree()->property_trees()->scroll_tree.Node( + middle_scrollable_->scroll_tree_index()); - // The bottom-right should hit the bottom layer's non-fast region. Though - // the middle layer is a composited scroller and is hit first, we cannot do - // a fast scroll because an ancestor on the scroll chain has hit a non-fast - // region. - InputHandler::ScrollStatus bottom_right_status = - impl->ScrollBegin(BeginState(gfx::Point(80, 80)).get(), - ui::ScrollInputType::kTouchscreen); - EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, bottom_right_status.thread); - EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, - bottom_right_status.main_thread_scrolling_reasons); + // The top-left hit should immediately hit the top layer's non-fast region. + { + auto status = impl->ScrollBegin( + BeginState(gfx::Point(20, 20), gfx::Vector2dF(0, 1)).get(), + ui::ScrollInputType::kTouchscreen); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + // Hitting a non fast region should request a hit test from the main + // thread. + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_TRUE(status.needs_main_thread_hit_test); + impl->ScrollEnd(); + } else { + // Prior to scroll unification, this forces scrolling to the main + // thread. + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, + status.main_thread_scrolling_reasons); + } + } + + // The top-right hit should hit the top layer but not the non-fast region + // so the scroll can be handled without involving the main thread. + { + InputHandler::ScrollStatus status = impl->ScrollBegin( + BeginState(gfx::Point(80, 20), gfx::Vector2dF(0, 1)).get(), + ui::ScrollInputType::kTouchscreen); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + } else { + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain, + status.main_thread_scrolling_reasons); + } + EXPECT_EQ(scroll_node, impl->CurrentlyScrollingNode()); + impl->ScrollEnd(); + } + + // The bottom-right should hit the bottom layer's non-fast region. + { + InputHandler::ScrollStatus status = impl->ScrollBegin( + BeginState(gfx::Point(80, 80), gfx::Vector2dF(0, 1)).get(), + ui::ScrollInputType::kTouchscreen); + if (base::FeatureList::IsEnabled(features::kScrollUnification)) { + // Even though the point intersects a non-fast region, the first hit + // layer is scrollable from the compositor thread so no need to involve + // the main thread. + EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + EXPECT_FALSE(status.needs_main_thread_hit_test); + EXPECT_EQ(scroll_node, impl->CurrentlyScrollingNode()); + impl->ScrollEnd(); + } else { + // Though the middle layer is a composited scroller and is hit first, we + // cannot do a fast scroll because an ancestor on the scroll chain has + // hit a non-fast region. + EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread); + EXPECT_EQ(MainThreadScrollingReason::kNonFastScrollableRegion, + status.main_thread_scrolling_reasons); + } + } EndTest(); } @@ -2501,5 +2746,70 @@ class NonScrollingNonFastScrollableRegion : public LayerTreeHostScrollTest { SINGLE_THREAD_TEST_F(NonScrollingNonFastScrollableRegion); +// This test verifies that scrolling in non layer list mode (used by UI +// compositor) is always "compositor scrolled", i.e. property trees are mutated +// and the updated layers redrawn. This test intentionally doesn't inherit +// from LayerTreeHostScrollTest since that enables LayerLists. +class UnifiedScrollingRepaintOnScroll : public LayerTreeTest { + public: + UnifiedScrollingRepaintOnScroll() { + scoped_feature_list.InitAndEnableFeature(features::kScrollUnification); + } + + void BeginTest() override { PostSetNeedsCommitToMainThread(); } + + void SetupTree() override { + LayerTreeTest::SetupTree(); + + layer_ = FakePictureLayer::Create(&client_); + layer_->SetScrollable(gfx::Size(10, 10)); + layer_->SetBounds(gfx::Size(100, 100)); + layer_->SetIsDrawable(true); + layer_->SetHitTestable(true); + layer_->SetElementId(LayerIdToElementIdForTesting(layer_->id())); + client_.set_bounds(layer_->bounds()); + layer_tree_host()->root_layer()->AddChild(layer_); + } + + void DrawLayersOnThread(LayerTreeHostImpl* impl) override { + if (is_done_) + return; + is_done_ = true; + EndTest(); + + TransformTree& transform_tree = + impl->active_tree()->property_trees()->transform_tree; + ASSERT_FALSE(transform_tree.needs_update()); + + // Perform a scroll over our FakePictureLayer. + { + InputHandler::ScrollStatus status = impl->ScrollBegin( + BeginState(gfx::Point(0, 0), gfx::Vector2dF(0, 10)).get(), + ui::ScrollInputType::kTouchscreen); + + ASSERT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread); + ASSERT_EQ(layer_->scroll_tree_index(), + impl->CurrentlyScrollingNode()->id); + + impl->ScrollUpdate( + UpdateState(gfx::Point(), gfx::Vector2dF(0, 10)).get()); + impl->ScrollEnd(); + } + + // All scrolling in non-layer-list mode (i.e. UI compositor) should be + // "compositor" scrolling so it should mutate the property tree and redraw, + // rather than relying on an update from the main thread. + ASSERT_TRUE(transform_tree.needs_update()); + } + + private: + bool is_done_ = false; + scoped_refptr<Layer> layer_; + FakeContentLayerClient client_; + base::test::ScopedFeatureList scoped_feature_list; +}; + +MULTI_THREAD_TEST_F(UnifiedScrollingRepaintOnScroll); + } // namespace } // namespace cc diff --git a/chromium/cc/trees/layer_tree_impl.cc b/chromium/cc/trees/layer_tree_impl.cc index 600c987976c..7ab7bf797ef 100644 --- a/chromium/cc/trees/layer_tree_impl.cc +++ b/chromium/cc/trees/layer_tree_impl.cc @@ -10,7 +10,9 @@ #include <algorithm> #include <iterator> #include <limits> +#include <memory> #include <set> +#include <utility> #include "base/containers/adapters.h" #include "base/debug/crash_logging.h" @@ -24,6 +26,7 @@ #include "base/trace_event/trace_event.h" #include "base/trace_event/traced_value.h" #include "cc/base/devtools_instrumentation.h" +#include "cc/base/features.h" #include "cc/base/histograms.h" #include "cc/base/math_util.h" #include "cc/base/synced_property.h" @@ -209,17 +212,38 @@ void LayerTreeImpl::DidUpdateScrollOffset(ElementId id) { return; } + // This bit controls whether we'll update the transform node based on a + // changed scroll offset. If scroll unification is off, we always do this + // because the scroll handling code will only invoke a scroll update on nodes + // that can compositor scroll. However, with scroll unification, we can + // mutate scroll nodes which have main thread scrolling reasons, or aren't + // backed by a layer at all. In those cases, we don't want to produce any + // immediate changes in the compositor, we want the scroll to propagate + // through Blink in a commit and have Blink update properties, paint, + // compositing, etc. Thus, we avoid mutating the transform tree in this case. + // TODO(bokan): We SetNeedsCommit in LTHI when a scroll happens but in a + // normal compositor scroll there isn't much urgency for a commit to be + // scheduled. We should look into what we can do to make sure this is + // proritized accordingly. https://crbug.com/1082618. + bool can_realize_scroll_on_compositor = + !base::FeatureList::IsEnabled(features::kScrollUnification) || + (scroll_node->is_composited && + !scroll_node->main_thread_scrolling_reasons); + DCHECK(scroll_node->transform_id != TransformTree::kInvalidNodeId); TransformTree& transform_tree = property_trees()->transform_tree; auto* transform_node = transform_tree.Node(scroll_node->transform_id); - if (transform_node->scroll_offset != scroll_tree.current_scroll_offset(id)) { - transform_node->scroll_offset = scroll_tree.current_scroll_offset(id); - transform_node->needs_local_transform_update = true; - transform_tree.set_needs_update(true); + if (can_realize_scroll_on_compositor) { + if (transform_node->scroll_offset != + scroll_tree.current_scroll_offset(id)) { + transform_node->scroll_offset = scroll_tree.current_scroll_offset(id); + transform_node->needs_local_transform_update = true; + transform_tree.set_needs_update(true); + } + transform_node->transform_changed = true; + property_trees()->changed = true; + set_needs_update_draw_properties(); } - transform_node->transform_changed = true; - property_trees()->changed = true; - set_needs_update_draw_properties(); if (IsActiveTree()) { // Ensure the other trees are kept in sync. @@ -419,6 +443,13 @@ void LayerTreeImpl::UpdateViewportContainerSizes() { OuterViewportScrollNode()->container_bounds.height() + scaled_bounds_delta.y(); outer_clip_node->clip.set_height(adjusted_container_height); + + // Expand all clips between the outer viewport and the inner viewport. + auto* outer_ancestor = property_trees->clip_tree.parent(outer_clip_node); + while (outer_ancestor && outer_ancestor->id != ClipTree::kRootNodeId) { + outer_ancestor->clip.Union(outer_clip_node->clip); + outer_ancestor = property_trees->clip_tree.parent(outer_ancestor); + } } anchor.ResetViewportToAnchoredPosition(); @@ -477,6 +508,16 @@ OwnedLayerImplList LayerTreeImpl::DetachLayersKeepingRootLayerForTesting() { } void LayerTreeImpl::SetPropertyTrees(PropertyTrees* property_trees) { + // Updating the scroll tree shouldn't clobber the currently scrolling node so + // stash it and restore it at the end of this method. To maintain the + // current scrolling node we need to use element ids which are stable across + // the property tree update in SetPropertyTrees. + ElementId scrolling_element_id; + if (IsActiveTree()) { + if (ScrollNode* scrolling_node = CurrentlyScrollingNode()) + scrolling_element_id = scrolling_node->element_id; + } + std::vector<std::unique_ptr<RenderSurfaceImpl>> old_render_surfaces; property_trees_.effect_tree.TakeRenderSurfaces(&old_render_surfaces); property_trees_ = *property_trees; @@ -493,6 +534,13 @@ void LayerTreeImpl::SetPropertyTrees(PropertyTrees* property_trees) { // effect tree. if (IsActiveTree()) property_trees_.effect_tree.set_needs_update(true); + + const ScrollNode* scrolling_node = nullptr; + if (scrolling_element_id) { + auto& scroll_tree = property_trees_.scroll_tree; + scrolling_node = scroll_tree.FindNodeFromElementId(scrolling_element_id); + } + SetCurrentlyScrollingNode(scrolling_node); } void LayerTreeImpl::PushPropertyTreesTo(LayerTreeImpl* target_tree) { @@ -508,21 +556,8 @@ void LayerTreeImpl::PushPropertyTreesTo(LayerTreeImpl* target_tree) { target_tree->MoveChangeTrackingToLayers(); } - // To maintain the current scrolling node we need to use element ids which - // are stable across the property tree update in SetPropertyTrees. - ElementId scrolling_element_id; - if (ScrollNode* scrolling_node = target_tree->CurrentlyScrollingNode()) - scrolling_element_id = scrolling_node->element_id; - target_tree->SetPropertyTrees(&property_trees_); - const ScrollNode* scrolling_node = nullptr; - if (scrolling_element_id) { - auto& scroll_tree = target_tree->property_trees()->scroll_tree; - scrolling_node = scroll_tree.FindNodeFromElementId(scrolling_element_id); - } - target_tree->SetCurrentlyScrollingNode(scrolling_node); - std::vector<EventMetrics> events_metrics; events_metrics.swap(events_metrics_from_main_thread_); target_tree->AppendEventsMetricsFromMainThread(std::move(events_metrics)); @@ -618,6 +653,13 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) { target_tree->HandleScrollbarShowRequestsFromMain(); target_tree->AddPresentationCallbacks(std::move(presentation_callbacks_)); presentation_callbacks_.clear(); + + if (delegated_ink_metadata_) { + TRACE_EVENT_INSTANT1("cc", "Delegated ink metadata pushed to tree", + TRACE_EVENT_SCOPE_THREAD, "point", + delegated_ink_metadata_->point().ToString()); + target_tree->set_delegated_ink_metadata(std::move(delegated_ink_metadata_)); + } } void LayerTreeImpl::HandleTickmarksVisibilityChange() { @@ -1581,12 +1623,8 @@ ImageAnimationController* LayerTreeImpl::image_animation_controller() const { return host_impl_->image_animation_controller(); } -FrameRateCounter* LayerTreeImpl::frame_rate_counter() const { - return host_impl_->fps_counter(); -} - -base::Optional<int> LayerTreeImpl::current_universal_throughput() { - return host_impl_->current_universal_throughput(); +DroppedFrameCounter* LayerTreeImpl::dropped_frame_counter() const { + return host_impl_->dropped_frame_counter(); } MemoryHistory* LayerTreeImpl::memory_history() const { @@ -1937,9 +1975,11 @@ void LayerTreeImpl::UnregisterScrollbar( if (scrollbar_ids.horizontal == Layer::INVALID_ID && scrollbar_ids.vertical == Layer::INVALID_ID) { element_id_to_scrollbar_layer_ids_.erase(scroll_element_id); - if (IsActiveTree()) { - host_impl_->DidUnregisterScrollbarLayer(scroll_element_id); - } + } + + if (IsActiveTree()) { + host_impl_->DidUnregisterScrollbarLayer(scroll_element_id, + scrollbar_layer->orientation()); } } @@ -2256,6 +2296,19 @@ LayerTreeImpl::FindLayersHitByPointInNonFastScrollableRegion( return layers; } +bool LayerTreeImpl::PointHitsNonFastScrollableRegion( + const gfx::PointF& screen_space_point, + const LayerImpl& layer) const { + // We assume the layer has already been hit tested. + DCHECK(PointHitsLayer(&layer, screen_space_point, nullptr)); + + if (layer.non_fast_scrollable_region().IsEmpty()) + return false; + + return PointHitsRegion(screen_space_point, layer.ScreenSpaceTransform(), + layer.non_fast_scrollable_region(), &layer); +} + struct HitTestFramedVisibleScrollableOrTouchableFunctor { bool operator()(LayerImpl* layer) const { return layer->HitTestable() && layer->frame_element_id(); diff --git a/chromium/cc/trees/layer_tree_impl.h b/chromium/cc/trees/layer_tree_impl.h index 5c2f586a0ea..d4583970c74 100644 --- a/chromium/cc/trees/layer_tree_impl.h +++ b/chromium/cc/trees/layer_tree_impl.h @@ -46,7 +46,7 @@ class ContextProvider; namespace cc { class DebugRectHistory; -class FrameRateCounter; +class DroppedFrameCounter; class HeadsUpDisplayLayerImpl; class ImageDecodeCache; class LayerTreeDebugState; @@ -127,8 +127,7 @@ class CC_EXPORT LayerTreeImpl { TileManager* tile_manager() const; ImageDecodeCache* image_decode_cache() const; ImageAnimationController* image_animation_controller() const; - FrameRateCounter* frame_rate_counter() const; - base::Optional<int> current_universal_throughput(); + DroppedFrameCounter* dropped_frame_counter() const; MemoryHistory* memory_history() const; DebugRectHistory* debug_rect_history() const; bool IsActiveTree() const; @@ -591,6 +590,8 @@ class CC_EXPORT LayerTreeImpl { // Return all layers with a hit non-fast scrollable region. std::vector<const LayerImpl*> FindLayersHitByPointInNonFastScrollableRegion( const gfx::PointF& screen_space_point); + bool PointHitsNonFastScrollableRegion(const gfx::PointF& scree_space_point, + const LayerImpl& layer) const; // Returns the ElementId representing a frame's document at the given point. // In cases where cc doesn't have enough information to perform accurate @@ -710,6 +711,18 @@ class CC_EXPORT LayerTreeImpl { return host_impl_->DrawTransform(); } + // These functions are used for plumbing DelegatedInkMetadata from blink + // through the compositor and into viz via a compositor frame. They should + // only be called after the JS API |updateInkTrailStartPoint| has been + // called, which populates the metadata with provided information. + void set_delegated_ink_metadata( + std::unique_ptr<viz::DelegatedInkMetadata> metadata) { + delegated_ink_metadata_ = std::move(metadata); + } + std::unique_ptr<viz::DelegatedInkMetadata> take_delegated_ink_metadata() { + return std::move(delegated_ink_metadata_); + } + protected: float ClampPageScaleFactorToLimits(float page_scale_factor) const; void PushPageScaleFactorAndLimits(const float* page_scale_factor, @@ -861,6 +874,8 @@ class CC_EXPORT LayerTreeImpl { // Event metrics that are reported back from the main thread. std::vector<EventMetrics> events_metrics_from_main_thread_; + + std::unique_ptr<viz::DelegatedInkMetadata> delegated_ink_metadata_; }; } // namespace cc diff --git a/chromium/cc/trees/layer_tree_settings.h b/chromium/cc/trees/layer_tree_settings.h index 95a901678c2..446d46764c5 100644 --- a/chromium/cc/trees/layer_tree_settings.h +++ b/chromium/cc/trees/layer_tree_settings.h @@ -187,10 +187,18 @@ class CC_EXPORT LayerTreeSettings { // Whether experimental de-jelly effect is allowed. bool allow_de_jelly_effect = false; + // Whether the compositor should attempt to sync with the scroll handlers + // before submitting a frame. + bool enable_synchronized_scrolling = true; + #if DCHECK_IS_ON() // Whether to check if any double blur exists. bool log_on_ui_double_background_blur = false; #endif + + // When enabled, enforces new interoperable semantics for 3D transforms. + // See crbug.com/1008483. + bool enable_transform_interop = false; }; class CC_EXPORT LayerListSettings : public LayerTreeSettings { diff --git a/chromium/cc/trees/mutator_host.h b/chromium/cc/trees/mutator_host.h index 1292e0ec826..e3cf671314b 100644 --- a/chromium/cc/trees/mutator_host.h +++ b/chromium/cc/trees/mutator_host.h @@ -160,7 +160,6 @@ class MutatorHost { // the scroller. Otherwise returns an invalid ElementId. virtual ElementId ImplOnlyScrollAnimatingElement() const = 0; - virtual size_t CompositedAnimationsCount() const = 0; virtual size_t MainThreadAnimationsCount() const = 0; virtual bool HasCustomPropertyAnimations() const = 0; virtual bool CurrentFrameHadRAF() const = 0; diff --git a/chromium/cc/trees/occlusion_tracker.h b/chromium/cc/trees/occlusion_tracker.h index d2498676dec..c734beff463 100644 --- a/chromium/cc/trees/occlusion_tracker.h +++ b/chromium/cc/trees/occlusion_tracker.h @@ -59,7 +59,7 @@ class CC_EXPORT OcclusionTracker { protected: struct StackObject { - StackObject() : target(0) {} + StackObject() : target(nullptr) {} explicit StackObject(const RenderSurfaceImpl* target) : target(target) {} const RenderSurfaceImpl* target; SimpleEnclosedRegion occlusion_from_outside_target; diff --git a/chromium/cc/trees/property_tree.cc b/chromium/cc/trees/property_tree.cc index cbdb9d43e73..00ce2f2e65d 100644 --- a/chromium/cc/trees/property_tree.cc +++ b/chromium/cc/trees/property_tree.cc @@ -493,24 +493,27 @@ void TransformTree::UpdateSnapping(TransformNode* node) { // rounded, then what we're after is the scroll delta X, where ST * X = ST'. // I.e., we want a transform that will realize our snap. It follows that // X = ST^-1 * ST'. We cache ST and ST^-1 to make this more efficient. - gfx::Transform rounded = ToScreen(node->id); - rounded.RoundTranslationComponents(); - gfx::Transform delta = FromScreen(node->id); - delta *= rounded; - - DCHECK(delta.IsApproximatelyIdentityOrTranslation(SkDoubleToScalar(1e-4))) + DCHECK_LT(node->id, static_cast<int>(cached_data_.size())); + gfx::Transform& to_screen = cached_data_[node->id].to_screen; + to_screen.RoundTranslationComponents(); + gfx::Transform& from_screen = cached_data_[node->id].from_screen; + gfx::Transform delta = from_screen; + delta *= to_screen; + + constexpr float kTolerance = 1e-4f; + DCHECK(delta.IsApproximatelyIdentityOrTranslation(kTolerance)) << delta.ToString(); gfx::Vector2dF translation = delta.To2dTranslation(); + node->snap_amount = translation; + if (translation.IsZero()) + return; - // Now that we have our delta, we must apply it to each of our combined, - // to/from matrices. - SetToScreen(node->id, rounded); - node->to_parent.Translate(translation.x(), translation.y()); - gfx::Transform from_screen = FromScreen(node->id); from_screen.matrix().postTranslate(-translation.x(), -translation.y(), 0); - SetFromScreen(node->id, from_screen); - node->snap_amount = translation; + node->to_parent.Translate(translation.x(), translation.y()); + // Avoid accumulation of errors in to_parent. + if (node->to_parent.IsApproximatelyIdentityOrIntegerTranslation(kTolerance)) + node->to_parent.RoundTranslationComponents(); } void TransformTree::UpdateTransformChanged(TransformNode* node, @@ -745,6 +748,17 @@ void EffectTree::UpdateHasMaskingChild(EffectNode* node, } } +void EffectTree::UpdateOnlyDrawsVisibleContent(EffectNode* node, + EffectNode* parent_node) { + node->only_draws_visible_content = !node->has_copy_request; + if (parent_node) + node->only_draws_visible_content &= parent_node->only_draws_visible_content; + if (!node->backdrop_filters.IsEmpty()) { + node->only_draws_visible_content &= + !node->backdrop_filters.HasFilterOfType(FilterOperation::ZOOM); + } +} + void EffectTree::UpdateSurfaceContentsScale(EffectNode* effect_node) { if (!effect_node->HasRenderSurface()) { effect_node->surface_contents_scale = gfx::Vector2dF(1.0f, 1.0f); @@ -829,6 +843,7 @@ void EffectTree::UpdateEffects(int id) { UpdateEffectChanged(node, parent_node); UpdateBackfaceVisibility(node, parent_node); UpdateHasMaskingChild(node, parent_node); + UpdateOnlyDrawsVisibleContent(node, parent_node); UpdateSurfaceContentsScale(node); } @@ -1273,6 +1288,8 @@ void ScrollTree::OnScrollOffsetAnimated(ElementId id, if (!property_trees()->is_active) return; + TRACE_EVENT2("cc", "ScrollTree::OnScrollOffsetAnimated", "x", + scroll_offset.x(), "y", scroll_offset.y()); ScrollNode* scroll_node = Node(scroll_tree_index); if (SetScrollOffset(id, ClampScrollOffsetToLimits(scroll_offset, *scroll_node))) @@ -1570,6 +1587,9 @@ void ScrollTree::SetBaseScrollOffset(ElementId id, bool ScrollTree::SetScrollOffset(ElementId id, const gfx::ScrollOffset& scroll_offset) { + // TODO(crbug.com/1087088): Remove TRACE_EVENT call when the bug is fixed + TRACE_EVENT2("cc", "ScrollTree::SetScrollOffset", "x", scroll_offset.x(), "y", + scroll_offset.y()); if (property_trees()->is_main_thread) { if (scroll_offset_map_[id] == scroll_offset) return false; diff --git a/chromium/cc/trees/property_tree.h b/chromium/cc/trees/property_tree.h index 4dcf7d7a0bd..6c41097cc7a 100644 --- a/chromium/cc/trees/property_tree.h +++ b/chromium/cc/trees/property_tree.h @@ -356,6 +356,7 @@ class CC_EXPORT EffectTree final : public PropertyTree<EffectNode> { void UpdateIsDrawn(EffectNode* node, EffectNode* parent_node); void UpdateBackfaceVisibility(EffectNode* node, EffectNode* parent_node); void UpdateHasMaskingChild(EffectNode* node, EffectNode* parent_node); + void UpdateOnlyDrawsVisibleContent(EffectNode* node, EffectNode* parent_node); // Stores copy requests, keyed by node id. std::unordered_multimap<int, std::unique_ptr<viz::CopyOutputRequest>> diff --git a/chromium/cc/trees/property_tree_builder.cc b/chromium/cc/trees/property_tree_builder.cc index b036be21cbd..fcf85d88d2d 100644 --- a/chromium/cc/trees/property_tree_builder.cc +++ b/chromium/cc/trees/property_tree_builder.cc @@ -612,6 +612,7 @@ void PropertyTreeBuilderContext::AddScrollNodeIfNeeded( node.user_scrollable_vertical = layer->GetUserScrollableVertical(); node.element_id = layer->element_id(); node.transform_id = data_for_children->transform_tree_parent; + node.is_composited = true; node_id = scroll_tree_.Insert(node, parent_id); data_for_children->scroll_tree_parent = node_id; diff --git a/chromium/cc/trees/property_tree_builder_unittest.cc b/chromium/cc/trees/property_tree_builder_unittest.cc index af760bc828a..183c3342de0 100644 --- a/chromium/cc/trees/property_tree_builder_unittest.cc +++ b/chromium/cc/trees/property_tree_builder_unittest.cc @@ -201,7 +201,7 @@ TEST_F(PropertyTreeBuilderTest, RenderSurfaceListForTransparentChild) { EXPECT_EQ(1U, GetRenderSurfaceList().size()); EXPECT_EQ(static_cast<viz::RenderPassId>(root->id()), GetRenderSurfaceList().at(0)->id()); - EXPECT_EQ(gfx::Rect(), ImplOf(root)->drawable_content_rect()); + EXPECT_EQ(gfx::Rect(), ImplOf(root)->visible_drawable_content_rect()); } TEST_F(PropertyTreeBuilderTest, diff --git a/chromium/cc/trees/proxy.h b/chromium/cc/trees/proxy.h index 0fe7a90fe3f..9afdb987bfc 100644 --- a/chromium/cc/trees/proxy.h +++ b/chromium/cc/trees/proxy.h @@ -8,7 +8,6 @@ #include <memory> #include <string> -#include "base/logging.h" #include "base/memory/ref_counted.h" #include "base/threading/platform_thread.h" #include "base/time/time.h" diff --git a/chromium/cc/trees/proxy_impl.cc b/chromium/cc/trees/proxy_impl.cc index 544ad6392e3..24e222ffbe0 100644 --- a/chromium/cc/trees/proxy_impl.cc +++ b/chromium/cc/trees/proxy_impl.cc @@ -370,26 +370,10 @@ void ProxyImpl::SetVideoNeedsBeginFrames(bool needs_begin_frames) { scheduler_->SetVideoNeedsBeginFrames(needs_begin_frames); } -size_t ProxyImpl::CompositedAnimationsCount() const { - return host_impl_->mutator_host()->CompositedAnimationsCount(); -} - -size_t ProxyImpl::MainThreadAnimationsCount() const { - return host_impl_->mutator_host()->MainThreadAnimationsCount(); -} - bool ProxyImpl::HasCustomPropertyAnimations() const { return host_impl_->mutator_host()->HasCustomPropertyAnimations(); } -bool ProxyImpl::CurrentFrameHadRAF() const { - return host_impl_->mutator_host()->CurrentFrameHadRAF(); -} - -bool ProxyImpl::NextFrameHasPendingRAF() const { - return host_impl_->mutator_host()->NextFrameHasPendingRAF(); -} - bool ProxyImpl::IsInsideDraw() { return inside_draw_; } @@ -542,14 +526,37 @@ void ProxyImpl::NotifyThroughputTrackerResults(CustomTrackerResults results) { proxy_main_weak_ptr_, std::move(results))); } +void ProxyImpl::SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) { + DCHECK(IsImplThread()); + MainThreadTaskRunner()->PostTask( + FROM_HERE, + base::BindOnce(&ProxyMain::SubmitThroughputData, proxy_main_weak_ptr_, + source_id, aggregated_percent, impl_percent, + main_percent)); +} + +void ProxyImpl::DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) { + DCHECK(IsImplThread()); + MainThreadTaskRunner()->PostTask( + FROM_HERE, base::BindOnce(&ProxyMain::DidObserveFirstScrollDelay, + proxy_main_weak_ptr_, first_scroll_delay, + first_scroll_timestamp)); +} + bool ProxyImpl::WillBeginImplFrame(const viz::BeginFrameArgs& args) { DCHECK(IsImplThread()); return host_impl_->WillBeginImplFrame(args); } -void ProxyImpl::DidFinishImplFrame() { +void ProxyImpl::DidFinishImplFrame( + const viz::BeginFrameArgs& last_activated_args) { DCHECK(IsImplThread()); - host_impl_->DidFinishImplFrame(scheduler_->last_activate_origin_frame_args()); + host_impl_->DidFinishImplFrame(last_activated_args); } void ProxyImpl::DidNotProduceFrame(const viz::BeginFrameAck& ack, @@ -703,9 +710,6 @@ DrawResult ProxyImpl::DrawInternal(bool forced_draw) { base::AutoReset<bool> mark_inside(&inside_draw_, true); - if (host_impl_->pending_tree()) - host_impl_->pending_tree()->UpdateDrawProperties(); - // This method is called on a forced draw, regardless of whether we are able // to produce a frame, as the calling site on main thread is blocked until its // request completes, and we signal completion here. If CanDraw() is false, we @@ -756,6 +760,12 @@ DrawResult ProxyImpl::DrawInternal(bool forced_draw) { proxy_main_weak_ptr_)); } + // The tile visibility/priority of the pending tree needs to be updated so + // that it doesn't get activated before the raster is complete. But this needs + // to happen after the draw, off of the critical path to draw. + if (host_impl_->pending_tree()) + host_impl_->pending_tree()->UpdateDrawProperties(); + DCHECK_NE(INVALID_RESULT, result); return result; } diff --git a/chromium/cc/trees/proxy_impl.h b/chromium/cc/trees/proxy_impl.h index 3050199e43d..dbe9b20d3ba 100644 --- a/chromium/cc/trees/proxy_impl.h +++ b/chromium/cc/trees/proxy_impl.h @@ -119,10 +119,18 @@ class CC_EXPORT ProxyImpl : public LayerTreeHostImplClient, void NotifyPaintWorkletStateChange( Scheduler::PaintWorkletState state) override; void NotifyThroughputTrackerResults(CustomTrackerResults results) override; + void SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) override; + void DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) override; // SchedulerClient implementation bool WillBeginImplFrame(const viz::BeginFrameArgs& args) override; - void DidFinishImplFrame() override; + void DidFinishImplFrame( + const viz::BeginFrameArgs& last_activated_args) override; void DidNotProduceFrame(const viz::BeginFrameAck& ack, FrameSkippedReason reason) override; void WillNotReceiveBeginFrame() override; @@ -140,11 +148,7 @@ class CC_EXPORT ProxyImpl : public LayerTreeHostImplClient, void ScheduledActionBeginMainFrameNotExpectedUntil( base::TimeTicks time) override; void FrameIntervalUpdated(base::TimeDelta interval) override {} - size_t CompositedAnimationsCount() const override; - size_t MainThreadAnimationsCount() const override; bool HasCustomPropertyAnimations() const override; - bool CurrentFrameHadRAF() const override; - bool NextFrameHasPendingRAF() const override; DrawResult DrawInternal(bool forced_draw); diff --git a/chromium/cc/trees/proxy_main.cc b/chromium/cc/trees/proxy_main.cc index 22976f62b02..1ad9795cd11 100644 --- a/chromium/cc/trees/proxy_main.cc +++ b/chromium/cc/trees/proxy_main.cc @@ -378,6 +378,22 @@ void ProxyMain::NotifyThroughputTrackerResults(CustomTrackerResults results) { layer_tree_host_->NotifyThroughputTrackerResults(std::move(results)); } +void ProxyMain::SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) { + DCHECK(!task_runner_provider_->IsImplThread()); + layer_tree_host_->SubmitThroughputData(source_id, aggregated_percent, + impl_percent, main_percent); +} + +void ProxyMain::DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) { + layer_tree_host_->DidObserveFirstScrollDelay(first_scroll_delay, + first_scroll_timestamp); +} + bool ProxyMain::IsStarted() const { DCHECK(IsMainThread()); return started_; diff --git a/chromium/cc/trees/proxy_main.h b/chromium/cc/trees/proxy_main.h index 8738cb1f38f..050af82306b 100644 --- a/chromium/cc/trees/proxy_main.h +++ b/chromium/cc/trees/proxy_main.h @@ -58,6 +58,12 @@ class CC_EXPORT ProxyMain : public Proxy { std::vector<LayerTreeHost::PresentationTimeCallback> callbacks, const gfx::PresentationFeedback& feedback); void NotifyThroughputTrackerResults(CustomTrackerResults results); + void SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent); + void DidObserveFirstScrollDelay(base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp); CommitPipelineStage max_requested_pipeline_stage() const { return max_requested_pipeline_stage_; diff --git a/chromium/cc/trees/render_frame_metadata.h b/chromium/cc/trees/render_frame_metadata.h index 43af9536c47..2b884785a9d 100644 --- a/chromium/cc/trees/render_frame_metadata.h +++ b/chromium/cc/trees/render_frame_metadata.h @@ -41,8 +41,7 @@ class CC_EXPORT RenderFrameMetadata { // specified. SkColor root_background_color = SK_ColorWHITE; - // Scroll offset of the root layer. This optional parameter is only valid - // during tests. + // Scroll offset of the root layer. base::Optional<gfx::Vector2dF> root_scroll_offset; // Selection region relative to the current viewport. If the selection is @@ -56,6 +55,11 @@ class CC_EXPORT RenderFrameMetadata { // are the same). bool is_mobile_optimized = false; + // Flag used to notify the browser process to start or stop forwarding points + // to viz for use in a delegated ink trail. True the entire time points should + // be forwarded, and forwarding stops as soon as it is false again. + bool has_delegated_ink_metadata = false; + // The device scale factor used to generate a CompositorFrame. float device_scale_factor = 1.f; diff --git a/chromium/cc/trees/scroll_and_scale_set.h b/chromium/cc/trees/scroll_and_scale_set.h index cef0850f33b..b7e9d9ed91a 100644 --- a/chromium/cc/trees/scroll_and_scale_set.h +++ b/chromium/cc/trees/scroll_and_scale_set.h @@ -97,6 +97,10 @@ struct CC_EXPORT ScrollAndScaleSet { // ended. bool scroll_gesture_did_end; + // Tracks whether there is an ongoing compositor-driven animation for a + // scroll. + bool ongoing_scroll_animation = false; + // Tracks different methods of scrolling (e.g. wheel, touch, precision // touchpad, etc.). ManipulationInfo manipulation_info; diff --git a/chromium/cc/trees/single_thread_proxy.cc b/chromium/cc/trees/single_thread_proxy.cc index 6f469a42c4e..c5449d5e85a 100644 --- a/chromium/cc/trees/single_thread_proxy.cc +++ b/chromium/cc/trees/single_thread_proxy.cc @@ -415,26 +415,10 @@ void SingleThreadProxy::SetVideoNeedsBeginFrames(bool needs_begin_frames) { scheduler_on_impl_thread_->SetVideoNeedsBeginFrames(needs_begin_frames); } -size_t SingleThreadProxy::CompositedAnimationsCount() const { - return 0; -} - -size_t SingleThreadProxy::MainThreadAnimationsCount() const { - return 0; -} - bool SingleThreadProxy::HasCustomPropertyAnimations() const { return false; } -bool SingleThreadProxy::CurrentFrameHadRAF() const { - return false; -} - -bool SingleThreadProxy::NextFrameHasPendingRAF() const { - return false; -} - bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; } @@ -635,7 +619,7 @@ void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time, // another draw will never be scheduled, so break remaining promises. host_impl_->active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS); - DidFinishImplFrame(); + DidFinishImplFrame(begin_frame_args); } } @@ -958,9 +942,9 @@ void SingleThreadProxy::ScheduledActionPerformImplSideInvalidation() { NotifyReadyToActivate(); } -void SingleThreadProxy::DidFinishImplFrame() { - host_impl_->DidFinishImplFrame( - scheduler_on_impl_thread_->last_activate_origin_frame_args()); +void SingleThreadProxy::DidFinishImplFrame( + const viz::BeginFrameArgs& last_activated_args) { + host_impl_->DidFinishImplFrame(last_activated_args); #if DCHECK_IS_ON() DCHECK(inside_impl_frame_) << "DidFinishImplFrame called while not inside an impl frame!"; diff --git a/chromium/cc/trees/single_thread_proxy.h b/chromium/cc/trees/single_thread_proxy.h index 96228af593c..ee1915c5222 100644 --- a/chromium/cc/trees/single_thread_proxy.h +++ b/chromium/cc/trees/single_thread_proxy.h @@ -77,7 +77,8 @@ class CC_EXPORT SingleThreadProxy : public Proxy, // SchedulerClient implementation bool WillBeginImplFrame(const viz::BeginFrameArgs& args) override; - void DidFinishImplFrame() override; + void DidFinishImplFrame( + const viz::BeginFrameArgs& last_activated_args) override; void DidNotProduceFrame(const viz::BeginFrameAck& ack, FrameSkippedReason reason) override; void WillNotReceiveBeginFrame() override; @@ -95,11 +96,7 @@ class CC_EXPORT SingleThreadProxy : public Proxy, void ScheduledActionBeginMainFrameNotExpectedUntil( base::TimeTicks time) override; void FrameIntervalUpdated(base::TimeDelta interval) override; - size_t CompositedAnimationsCount() const override; - size_t MainThreadAnimationsCount() const override; bool HasCustomPropertyAnimations() const override; - bool CurrentFrameHadRAF() const override; - bool NextFrameHasPendingRAF() const override; // LayerTreeHostImplClient implementation void DidLoseLayerTreeFrameSinkOnImplThread() override; @@ -137,9 +134,21 @@ class CC_EXPORT SingleThreadProxy : public Proxy, void NotifyPaintWorkletStateChange( Scheduler::PaintWorkletState state) override; void NotifyThroughputTrackerResults(CustomTrackerResults results) override; + void SubmitThroughputData(ukm::SourceId source_id, + int aggregated_percent, + int impl_percent, + base::Optional<int> main_percent) override {} void RequestNewLayerTreeFrameSink(); + void DidObserveFirstScrollDelay( + base::TimeDelta first_scroll_delay, + base::TimeTicks first_scroll_timestamp) override { + // Single-threaded mode is only for browser compositing and for renderers in + // layout tests. This will still get called in the latter case, but we don't + // need to record UKM in that case. + } + // Called by the legacy path where RenderWidget does the scheduling. // Rasterization of tiles is only performed when |raster| is true. void CompositeImmediately(base::TimeTicks frame_begin_time, bool raster); diff --git a/chromium/cc/trees/task_runner_provider.h b/chromium/cc/trees/task_runner_provider.h index 0bc19d31f38..232bc6da0f6 100644 --- a/chromium/cc/trees/task_runner_provider.h +++ b/chromium/cc/trees/task_runner_provider.h @@ -8,7 +8,7 @@ #include <memory> #include <string> -#include "base/logging.h" +#include "base/check.h" #include "base/memory/ptr_util.h" #include "base/memory/ref_counted.h" #include "base/single_thread_task_runner.h" diff --git a/chromium/cc/trees/transform_node.cc b/chromium/cc/trees/transform_node.cc index 780bba5ec67..b19c820baab 100644 --- a/chromium/cc/trees/transform_node.cc +++ b/chromium/cc/trees/transform_node.cc @@ -32,6 +32,7 @@ TransformNode::TransformNode() moved_by_outer_viewport_bounds_delta_y(false), in_subtree_of_page_scale_layer(false), transform_changed(false), + delegates_to_parent_for_backface(false), maximum_animation_scale(kNotScaled), starting_animation_scale(kNotScaled) {} @@ -62,6 +63,8 @@ bool TransformNode::operator==(const TransformNode& other) const { other.moved_by_outer_viewport_bounds_delta_y && in_subtree_of_page_scale_layer == other.in_subtree_of_page_scale_layer && + delegates_to_parent_for_backface == + other.delegates_to_parent_for_backface && transform_changed == other.transform_changed && scroll_offset == other.scroll_offset && snap_amount == other.snap_amount && diff --git a/chromium/cc/trees/transform_node.h b/chromium/cc/trees/transform_node.h index 401af01e617..47bb059ea1c 100644 --- a/chromium/cc/trees/transform_node.h +++ b/chromium/cc/trees/transform_node.h @@ -105,6 +105,10 @@ struct CC_EXPORT TransformNode { // We need to track changes to to_screen transform to compute the damage rect. bool transform_changed : 1; + // Whether the parent transform node should be used for checking backface + // visibility, not this transform one. + bool delegates_to_parent_for_backface : 1; + gfx::ScrollOffset scroll_offset; // This value stores the snapped amount whenever we snap. If the snap is due diff --git a/chromium/cc/trees/ukm_manager.cc b/chromium/cc/trees/ukm_manager.cc index 2141cf1a21c..9d4eab1315f 100644 --- a/chromium/cc/trees/ukm_manager.cc +++ b/chromium/cc/trees/ukm_manager.cc @@ -4,7 +4,12 @@ #include "cc/trees/ukm_manager.h" +#include <algorithm> +#include <utility> + +#include "cc/metrics/compositor_frame_reporter.h" #include "cc/metrics/throughput_ukm_reporter.h" +#include "components/viz/common/quads/compositor_frame.h" #include "services/metrics/public/cpp/ukm_builders.h" #include "services/metrics/public/cpp/ukm_recorder.h" @@ -187,11 +192,13 @@ void UkmManager::RecordAggregateThroughput(AggregationType aggregation_type, builder.Record(recorder_.get()); } -void UkmManager::RecordLatencyUKM( +void UkmManager::RecordCompositorLatencyUKM( CompositorFrameReporter::FrameReportType report_type, const std::vector<CompositorFrameReporter::StageData>& stage_history, const CompositorFrameReporter::ActiveTrackers& active_trackers, const viz::FrameTimingDetails& viz_breakdown) const { + using StageType = CompositorFrameReporter::StageType; + ukm::builders::Graphics_Smoothness_Latency builder(source_id_); if (report_type == CompositorFrameReporter::FrameReportType::kDroppedFrame) { @@ -202,7 +209,7 @@ void UkmManager::RecordLatencyUKM( for (const CompositorFrameReporter::StageData& stage : stage_history) { switch (stage.stage_type) { #define CASE_FOR_STAGE(name) \ - case CompositorFrameReporter::StageType::k##name: \ + case StageType::k##name: \ builder.Set##name((stage.end_time - stage.start_time).InMicroseconds()); \ break; CASE_FOR_STAGE(BeginImplFrameToSendBeginMainFrame); @@ -215,8 +222,7 @@ void UkmManager::RecordLatencyUKM( #undef CASE_FOR_STAGE // Break out kSubmitCompositorFrameToPresentationCompositorFrame to report // the viz breakdown. - case CompositorFrameReporter::StageType:: - kSubmitCompositorFrameToPresentationCompositorFrame: + case StageType::kSubmitCompositorFrameToPresentationCompositorFrame: builder.SetSubmitCompositorFrameToPresentationCompositorFrame( (stage.end_time - stage.start_time).InMicroseconds()); if (viz_breakdown.received_compositor_frame_timestamp.is_null()) @@ -287,4 +293,80 @@ void UkmManager::RecordLatencyUKM( builder.Record(recorder_.get()); } +void UkmManager::RecordEventLatencyUKM( + const std::vector<EventMetrics>& events_metrics, + const std::vector<CompositorFrameReporter::StageData>& stage_history, + const viz::FrameTimingDetails& viz_breakdown) const { + using StageType = CompositorFrameReporter::StageType; + + for (const EventMetrics& event_metrics : events_metrics) { + ukm::builders::Graphics_Smoothness_EventLatency builder(source_id_); + + builder.SetEventType(static_cast<int64_t>(event_metrics.type())); + + if (event_metrics.scroll_type()) { + builder.SetScrollInputType( + static_cast<int64_t>(*event_metrics.scroll_type())); + + if (!viz_breakdown.swap_timings.is_null()) { + builder.SetTotalLatencyToSwapEnd( + (viz_breakdown.swap_timings.swap_end - event_metrics.time_stamp()) + .InMicroseconds()); + } + } + + // It is possible for an event to arrive in the compositor in the middle of + // a frame (e.g. the browser received the event *after* renderer received a + // begin-impl, and the event reached the compositor before that frame + // ended). To handle such cases, find the first stage that happens after the + // event's arrival in the browser. + auto stage_it = std::find_if( + stage_history.begin(), stage_history.end(), + [&event_metrics](const CompositorFrameReporter::StageData& stage) { + return stage.start_time > event_metrics.time_stamp(); + }); + // TODO(crbug.com/1079116): Ideally, at least the start time of + // SubmitCompositorFrameToPresentationCompositorFrame stage should be + // greater than the event time stamp, but apparently, this is not always the + // case (see crbug.com/1093698). For now, skip to the next event in such + // cases. Hopefully, the work to reduce discrepancies between the new + // EventLatency and the old Event.Latency metrics would fix this issue. If + // not, we need to reconsider investigating this issue. + if (stage_it == stage_history.end()) + continue; + + builder.SetBrowserToRendererCompositor( + (stage_it->start_time - event_metrics.time_stamp()).InMicroseconds()); + + for (; stage_it != stage_history.end(); ++stage_it) { + // Total latency is calculated since the event timestamp. + const base::TimeTicks start_time = + stage_it->stage_type == StageType::kTotalLatency + ? event_metrics.time_stamp() + : stage_it->start_time; + + switch (stage_it->stage_type) { +#define CASE_FOR_STAGE(name) \ + case StageType::k##name: \ + builder.Set##name((stage_it->end_time - start_time).InMicroseconds()); \ + break; + CASE_FOR_STAGE(BeginImplFrameToSendBeginMainFrame); + CASE_FOR_STAGE(SendBeginMainFrameToCommit); + CASE_FOR_STAGE(Commit); + CASE_FOR_STAGE(EndCommitToActivation); + CASE_FOR_STAGE(Activation); + CASE_FOR_STAGE(EndActivateToSubmitCompositorFrame); + CASE_FOR_STAGE(SubmitCompositorFrameToPresentationCompositorFrame); + CASE_FOR_STAGE(TotalLatency); +#undef CASE_FOR_STAGE + default: + NOTREACHED(); + break; + } + } + + builder.Record(recorder_.get()); + } +} + } // namespace cc diff --git a/chromium/cc/trees/ukm_manager.h b/chromium/cc/trees/ukm_manager.h index 50653814f85..6a2cc1c03db 100644 --- a/chromium/cc/trees/ukm_manager.h +++ b/chromium/cc/trees/ukm_manager.h @@ -5,9 +5,14 @@ #ifndef CC_TREES_UKM_MANAGER_H_ #define CC_TREES_UKM_MANAGER_H_ +#include <memory> +#include <vector> + #include "cc/cc_export.h" #include "cc/metrics/compositor_frame_reporter.h" +#include "cc/metrics/event_metrics.h" #include "cc/metrics/frame_sequence_metrics.h" +#include "components/viz/common/frame_timing_details.h" #include "services/metrics/public/cpp/ukm_source_id.h" #include "url/gurl.h" @@ -33,6 +38,7 @@ class CC_EXPORT UkmManager { ~UkmManager(); void SetSourceId(ukm::SourceId source_id); + ukm::SourceId source_id() const { return source_id_; } // These metrics are recorded while a user interaction is in progress. void SetUserInteractionInProgress(bool in_progress); @@ -48,12 +54,17 @@ class CC_EXPORT UkmManager { int64_t throughput) const; void RecordAggregateThroughput(AggregationType aggregation_type, int64_t throughput_percent) const; - void RecordLatencyUKM( + void RecordCompositorLatencyUKM( CompositorFrameReporter::FrameReportType report_type, const std::vector<CompositorFrameReporter::StageData>& stage_history, const CompositorFrameReporter::ActiveTrackers& active_trackers, const viz::FrameTimingDetails& viz_breakdown) const; + void RecordEventLatencyUKM( + const std::vector<EventMetrics>& events_metrics, + const std::vector<CompositorFrameReporter::StageData>& stage_history, + const viz::FrameTimingDetails& viz_breakdown) const; + ukm::UkmRecorder* recorder_for_testing() { return recorder_.get(); } private: diff --git a/chromium/cc/trees/ukm_manager_unittest.cc b/chromium/cc/trees/ukm_manager_unittest.cc index 9f4dd926f5b..2b55162d45f 100644 --- a/chromium/cc/trees/ukm_manager_unittest.cc +++ b/chromium/cc/trees/ukm_manager_unittest.cc @@ -4,7 +4,14 @@ #include "cc/trees/ukm_manager.h" +#include <vector> + +#include "base/time/time.h" +#include "cc/metrics/compositor_frame_reporter.h" +#include "cc/metrics/event_metrics.h" #include "components/ukm/test_ukm_recorder.h" +#include "components/viz/common/frame_timing_details.h" +#include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" #include "url/gurl.h" @@ -23,6 +30,55 @@ const char kCheckerboardAreaRatio[] = "CheckerboardedContentAreaRatio"; const char kMissingTiles[] = "NumMissingTiles"; const char kCheckerboardedImagesCount[] = "CheckerboardedImagesCount"; +// Names of compositor/event latency UKM events. +const char kCompositorLatency[] = "Graphics.Smoothness.Latency"; +const char kEventLatency[] = "Graphics.Smoothness.EventLatency"; + +// Names of enum metrics used in compositor/event latency UKM metrics. +const char kMissedFrame[] = "MissedFrame"; +const char kEventType[] = "EventType"; +const char kScrollInputType[] = "ScrollInputType"; + +// Names of compositor stages and substages used in compositor/event latency UKM +// metrics. +const char kBrowserToRendererCompositor[] = "BrowserToRendererCompositor"; +const char kBeginImplFrameToSendBeginMainFrame[] = + "BeginImplFrameToSendBeginMainFrame"; +const char kSendBeginMainFrameToCommit[] = "SendBeginMainFrameToCommit"; +const char kCommit[] = "Commit"; +const char kEndCommitToActivation[] = "EndCommitToActivation"; +const char kActivation[] = "Activation"; +const char kEndActivateToSubmitCompositorFrame[] = + "EndActivateToSubmitCompositorFrame"; +const char kSubmitCompositorFrameToPresentationCompositorFrame[] = + "SubmitCompositorFrameToPresentationCompositorFrame"; +const char kVizBreakdownSubmitToReceiveCompositorFrame[] = + "SubmitCompositorFrameToPresentationCompositorFrame." + "SubmitToReceiveCompositorFrame"; +const char kVizBreakdownReceivedCompositorFrameToStartDraw[] = + "SubmitCompositorFrameToPresentationCompositorFrame." + "ReceivedCompositorFrameToStartDraw"; +const char kVizBreakdownStartDrawToSwapStart[] = + "SubmitCompositorFrameToPresentationCompositorFrame.StartDrawToSwapStart"; +const char kVizBreakdownSwapStartToSwapEnd[] = + "SubmitCompositorFrameToPresentationCompositorFrame.SwapStartToSwapEnd"; +const char kVizBreakdownSwapEndToPresentationCompositorFrame[] = + "SubmitCompositorFrameToPresentationCompositorFrame." + "SwapEndToPresentationCompositorFrame"; +const char kTotalLatencyToSwapEnd[] = "TotalLatencyToSwapEnd"; +const char kTotalLatency[] = "TotalLatency"; + +// Names of frame sequence types use in compositor latency UKM metrics (see +// FrameSequenceTrackerType enum). +const char kCompositorAnimation[] = "CompositorAnimation"; +const char kMainThreadAnimation[] = "MainThreadAnimation"; +const char kPinchZoom[] = "PinchZoom"; +const char kRAF[] = "RAF"; +const char kTouchScroll[] = "TouchScroll"; +const char kUniversal[] = "Universal"; +const char kVideo[] = "Video"; +const char kWheelScroll[] = "WheelScroll"; + class UkmManagerTest : public testing::Test { public: UkmManagerTest() { @@ -36,6 +92,8 @@ class UkmManagerTest : public testing::Test { manager_->SetSourceId(kTestSourceId1); } + ~UkmManagerTest() override = default; + protected: ukm::TestUkmRecorder* test_ukm_recorder_; std::unique_ptr<UkmManager> manager_; @@ -99,5 +157,300 @@ TEST_F(UkmManagerTest, Basic) { } } +class UkmManagerCompositorLatencyTest + : public UkmManagerTest, + public testing::WithParamInterface< + CompositorFrameReporter::FrameReportType> { + public: + UkmManagerCompositorLatencyTest() : report_type_(GetParam()) {} + ~UkmManagerCompositorLatencyTest() override = default; + + protected: + CompositorFrameReporter::FrameReportType report_type() const { + return report_type_; + } + + private: + CompositorFrameReporter::FrameReportType report_type_; +}; + +INSTANTIATE_TEST_SUITE_P( + All, + UkmManagerCompositorLatencyTest, + testing::Values( + CompositorFrameReporter::FrameReportType::kNonDroppedFrame, + CompositorFrameReporter::FrameReportType::kMissedDeadlineFrame, + CompositorFrameReporter::FrameReportType::kDroppedFrame, + CompositorFrameReporter::FrameReportType::kCompositorOnlyFrame)); + +TEST_P(UkmManagerCompositorLatencyTest, CompositorLatency) { + base::TimeTicks now = base::TimeTicks::Now(); + + const base::TimeTicks begin_impl_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks begin_main_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks begin_commit_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks end_commit_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks begin_activate_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks end_activate_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks submit_time = + (now += base::TimeDelta::FromMicroseconds(10)); + + viz::FrameTimingDetails viz_breakdown; + viz_breakdown.received_compositor_frame_timestamp = + (now += base::TimeDelta::FromMicroseconds(1)); + viz_breakdown.draw_start_timestamp = + (now += base::TimeDelta::FromMicroseconds(2)); + viz_breakdown.swap_timings.swap_start = + (now += base::TimeDelta::FromMicroseconds(3)); + viz_breakdown.swap_timings.swap_end = + (now += base::TimeDelta::FromMicroseconds(4)); + viz_breakdown.presentation_feedback.timestamp = + (now += base::TimeDelta::FromMicroseconds(5)); + + std::vector<CompositorFrameReporter::StageData> stage_history = { + { + CompositorFrameReporter::StageType:: + kBeginImplFrameToSendBeginMainFrame, + begin_impl_time, + begin_main_time, + }, + { + CompositorFrameReporter::StageType::kSendBeginMainFrameToCommit, + begin_main_time, + begin_commit_time, + }, + { + CompositorFrameReporter::StageType::kCommit, + begin_commit_time, + end_commit_time, + }, + { + CompositorFrameReporter::StageType::kEndCommitToActivation, + end_commit_time, + begin_activate_time, + }, + { + CompositorFrameReporter::StageType::kActivation, + begin_activate_time, + end_activate_time, + }, + { + CompositorFrameReporter::StageType:: + kEndActivateToSubmitCompositorFrame, + end_activate_time, + submit_time, + }, + { + CompositorFrameReporter::StageType:: + kSubmitCompositorFrameToPresentationCompositorFrame, + submit_time, + viz_breakdown.presentation_feedback.timestamp, + }, + { + CompositorFrameReporter::StageType::kTotalLatency, + begin_impl_time, + viz_breakdown.presentation_feedback.timestamp, + }, + }; + + CompositorFrameReporter::ActiveTrackers active_trackers; + active_trackers.set( + static_cast<size_t>(FrameSequenceTrackerType::kTouchScroll)); + active_trackers.set( + static_cast<size_t>(FrameSequenceTrackerType::kCompositorAnimation)); + active_trackers.set( + static_cast<size_t>(FrameSequenceTrackerType::kUniversal)); + + manager_->RecordCompositorLatencyUKM(report_type(), stage_history, + active_trackers, viz_breakdown); + + const auto& entries = + test_ukm_recorder_->GetEntriesByName(kCompositorLatency); + EXPECT_EQ(1u, entries.size()); + const auto* entry = entries[0]; + + EXPECT_NE(ukm::kInvalidSourceId, entry->source_id); + test_ukm_recorder_->ExpectEntrySourceHasUrl(entry, GURL(kTestUrl)); + + if (report_type() == + CompositorFrameReporter::FrameReportType::kDroppedFrame) { + test_ukm_recorder_->ExpectEntryMetric(entry, kMissedFrame, true); + } else { + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kMissedFrame)); + } + + test_ukm_recorder_->ExpectEntryMetric( + entry, kBeginImplFrameToSendBeginMainFrame, + (begin_main_time - begin_impl_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kSendBeginMainFrameToCommit, + (begin_commit_time - begin_main_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kCommit, (end_commit_time - begin_commit_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kEndCommitToActivation, + (begin_activate_time - end_commit_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kActivation, + (end_activate_time - begin_activate_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kEndActivateToSubmitCompositorFrame, + (submit_time - end_activate_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kSubmitCompositorFrameToPresentationCompositorFrame, + (viz_breakdown.presentation_feedback.timestamp - submit_time) + .InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kVizBreakdownSubmitToReceiveCompositorFrame, + (viz_breakdown.received_compositor_frame_timestamp - submit_time) + .InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kVizBreakdownReceivedCompositorFrameToStartDraw, + (viz_breakdown.draw_start_timestamp - + viz_breakdown.received_compositor_frame_timestamp) + .InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric(entry, + kVizBreakdownStartDrawToSwapStart, + (viz_breakdown.swap_timings.swap_start - + viz_breakdown.draw_start_timestamp) + .InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric(entry, kVizBreakdownSwapStartToSwapEnd, + (viz_breakdown.swap_timings.swap_end - + viz_breakdown.swap_timings.swap_start) + .InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kVizBreakdownSwapEndToPresentationCompositorFrame, + (viz_breakdown.presentation_feedback.timestamp - + viz_breakdown.swap_timings.swap_end) + .InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kTotalLatency, + (viz_breakdown.presentation_feedback.timestamp - begin_impl_time) + .InMicroseconds()); + + test_ukm_recorder_->ExpectEntryMetric(entry, kCompositorAnimation, true); + test_ukm_recorder_->ExpectEntryMetric(entry, kTouchScroll, true); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kMainThreadAnimation)); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kPinchZoom)); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kRAF)); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kUniversal)); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kVideo)); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kWheelScroll)); +} + +TEST_F(UkmManagerTest, EventLatency) { + base::TimeTicks now = base::TimeTicks::Now(); + + const base::TimeTicks event_time = now; + std::unique_ptr<EventMetrics> event_metrics_ptrs[] = { + EventMetrics::Create(ui::ET_GESTURE_SCROLL_BEGIN, event_time, + ui::ScrollInputType::kWheel), + EventMetrics::Create(ui::ET_GESTURE_SCROLL_UPDATE, event_time, + ui::ScrollInputType::kWheel), + EventMetrics::Create(ui::ET_GESTURE_SCROLL_UPDATE, event_time, + ui::ScrollInputType::kWheel), + }; + EXPECT_THAT(event_metrics_ptrs, ::testing::Each(::testing::NotNull())); + std::vector<EventMetrics> events_metrics = { + *event_metrics_ptrs[0], *event_metrics_ptrs[1], *event_metrics_ptrs[2]}; + + const base::TimeTicks begin_impl_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks end_activate_time = + (now += base::TimeDelta::FromMicroseconds(10)); + const base::TimeTicks submit_time = + (now += base::TimeDelta::FromMicroseconds(10)); + + viz::FrameTimingDetails viz_breakdown; + viz_breakdown.received_compositor_frame_timestamp = + (now += base::TimeDelta::FromMicroseconds(1)); + viz_breakdown.draw_start_timestamp = + (now += base::TimeDelta::FromMicroseconds(2)); + viz_breakdown.swap_timings.swap_start = + (now += base::TimeDelta::FromMicroseconds(3)); + viz_breakdown.swap_timings.swap_end = + (now += base::TimeDelta::FromMicroseconds(4)); + viz_breakdown.presentation_feedback.timestamp = + (now += base::TimeDelta::FromMicroseconds(5)); + + const base::TimeTicks swap_end_time = viz_breakdown.swap_timings.swap_end; + const base::TimeTicks present_time = + viz_breakdown.presentation_feedback.timestamp; + + std::vector<CompositorFrameReporter::StageData> stage_history = { + { + CompositorFrameReporter::StageType:: + kBeginImplFrameToSendBeginMainFrame, + begin_impl_time, + end_activate_time, + }, + { + CompositorFrameReporter::StageType:: + kEndActivateToSubmitCompositorFrame, + end_activate_time, + submit_time, + }, + { + CompositorFrameReporter::StageType:: + kSubmitCompositorFrameToPresentationCompositorFrame, + submit_time, + present_time, + }, + { + CompositorFrameReporter::StageType::kTotalLatency, + event_time, + present_time, + }, + }; + + manager_->RecordEventLatencyUKM(events_metrics, stage_history, viz_breakdown); + + const auto& entries = test_ukm_recorder_->GetEntriesByName(kEventLatency); + EXPECT_EQ(3u, entries.size()); + for (size_t i = 0; i < entries.size(); i++) { + const auto* entry = entries[i]; + const auto* event_metrics = event_metrics_ptrs[i].get(); + + EXPECT_NE(ukm::kInvalidSourceId, entry->source_id); + test_ukm_recorder_->ExpectEntrySourceHasUrl(entry, GURL(kTestUrl)); + + test_ukm_recorder_->ExpectEntryMetric( + entry, kEventType, static_cast<int64_t>(event_metrics->type())); + test_ukm_recorder_->ExpectEntryMetric( + entry, kScrollInputType, + static_cast<int64_t>(*event_metrics->scroll_type())); + + test_ukm_recorder_->ExpectEntryMetric( + entry, kBrowserToRendererCompositor, + (begin_impl_time - event_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kBeginImplFrameToSendBeginMainFrame, + (end_activate_time - begin_impl_time).InMicroseconds()); + EXPECT_FALSE( + test_ukm_recorder_->EntryHasMetric(entry, kSendBeginMainFrameToCommit)); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kCommit)); + EXPECT_FALSE( + test_ukm_recorder_->EntryHasMetric(entry, kEndCommitToActivation)); + EXPECT_FALSE(test_ukm_recorder_->EntryHasMetric(entry, kActivation)); + test_ukm_recorder_->ExpectEntryMetric( + entry, kEndActivateToSubmitCompositorFrame, + (submit_time - end_activate_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kSubmitCompositorFrameToPresentationCompositorFrame, + (present_time - submit_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kTotalLatencyToSwapEnd, + (swap_end_time - event_time).InMicroseconds()); + test_ukm_recorder_->ExpectEntryMetric( + entry, kTotalLatency, (present_time - event_time).InMicroseconds()); + } +} + } // namespace } // namespace cc |