| // Copyright 2016 Google Inc. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "cobalt/renderer/submission_queue.h" |
| |
| #include <cmath> |
| |
| #include "base/debug/trace_event.h" |
| #include "base/logging.h" |
| #include "base/string_number_conversions.h" |
| #include "cobalt/base/polymorphic_downcast.h" |
| #include "cobalt/render_tree/animations/animate_node.h" |
| |
| namespace cobalt { |
| namespace renderer { |
| |
| // The maximum change (in units of ms/s) of to_submission_time_in_ms_. This |
| // value must be less than 1000ms/s, or else it might be possible to adjust |
| // our render time/submission time offset by less than -1 second per second, |
| // meaning that we would move backwards in time. We keep this at a healthy |
| // value of 800ms. This also acts as a crude form of regularization. |
| const double kMaxSlopeMagnitude = 800.0; |
| |
| SubmissionQueue::SubmissionQueue( |
| size_t max_queue_size, base::TimeDelta time_to_converge, |
| const DisposeSubmissionFunction& dispose_function) |
| : max_queue_size_(max_queue_size), |
| dispose_function_(dispose_function), |
| to_submission_time_in_ms_(time_to_converge, kMaxSlopeMagnitude), |
| to_submission_time_cval_( |
| "Renderer.ToSubmissionTime", base::TimeDelta(), |
| "The current difference in milliseconds between the layout's clock " |
| "and the renderer's clock. The absolute value does not mean much, " |
| "but how it changes as the user navigates can show how the " |
| "renderer's clock changes relative to layout's clock."), |
| queue_size_( |
| "Renderer.SubmissionQueueSize", 0, |
| "The current size of the renderer submission queue. Each item in " |
| "queue contains a render tree and associated animations.") {} |
| |
| void SubmissionQueue::PushSubmission(const Submission& submission, |
| const base::TimeTicks& now) { |
| TRACE_EVENT0("cobalt::renderer", "SubmissionQueue::PushSubmission()"); |
| |
| CheckThatNowIsMonotonicallyIncreasing(now); |
| |
| if (submission_queue_.size() >= max_queue_size_) { |
| // If we are at capacity, then make room for the new submission by erasing |
| // our first element. |
| submission_queue_.pop_front(); |
| |
| // Ensure that the next oldest item in the queue is older than the current |
| // time. If this is not the case, snap time forward so that it is. |
| double to_front_submission_time_in_ms = |
| (submission_queue_.front().time_offset - render_time(now)) |
| .InMillisecondsF(); |
| if (to_submission_time_in_ms_.GetValueAtTime(now) < |
| to_front_submission_time_in_ms) { |
| to_submission_time_in_ms_.SetTarget(to_front_submission_time_in_ms, now); |
| to_submission_time_in_ms_.SnapToTarget(); |
| } |
| } |
| |
| base::TimeDelta latest_to_submission_time = |
| submission.time_offset - render_time(now); |
| |
| double latest_to_submission_time_in_ms = |
| latest_to_submission_time.InMillisecondsF(); |
| |
| to_submission_time_in_ms_.SetTarget(latest_to_submission_time_in_ms, now); |
| |
| // Snap time to the new submission if no existing animations are playing both |
| // currently and during the time that we are snapping to. |
| if (submission_queue_.size() == 1 && |
| submission_queue_.front().render_tree->GetTypeId() == |
| base::GetTypeId<render_tree::animations::AnimateNode>()) { |
| render_tree::animations::AnimateNode* animate_node = |
| base::polymorphic_downcast<render_tree::animations::AnimateNode*>( |
| submission_queue_.front().render_tree.get()); |
| |
| // Check the expiration of only animations that depend on the time |
| // parameter, since they are the only ones that will be affected by snapping |
| // time. |
| if (animate_node->depends_on_time_expiry() <= submission_time(now) && |
| animate_node->depends_on_time_expiry() <= |
| latest_to_submission_time + render_time(now)) { |
| to_submission_time_in_ms_.SnapToTarget(); |
| } |
| } |
| |
| // Save the new submission. |
| submission_queue_.push_back(submission); |
| |
| // Possibly purge old stale submissions. |
| PurgeStaleSubmissionsFromQueue(now); |
| } |
| |
| Submission SubmissionQueue::GetCurrentSubmission(const base::TimeTicks& now) { |
| TRACE_EVENT0("cobalt::renderer", "SubmissionQueue::GetCurrentSubmission()"); |
| |
| CheckThatNowIsMonotonicallyIncreasing(now); |
| |
| DCHECK(!submission_queue_.empty()); |
| |
| // First get rid of any stale submissions from our queue. |
| PurgeStaleSubmissionsFromQueue(now); |
| |
| // Create a new submission with an updated time offset to account for the |
| // fact that time has passed since it was submitted. |
| Submission updated_time_submission(submission_queue_.front()); |
| |
| // Our current clock should always be setup (via PushSubmission()) such |
| // that it is always larger than the front of the queue. |
| DCHECK_GE(to_submission_time_in_ms_.GetValueAtTime(now), |
| (submission_queue_.front().time_offset - render_time(now)) |
| .InMillisecondsF()); |
| |
| base::TimeDelta updated_time = submission_time(now); |
| |
| // This if statement is very similar to the DCHECK above, but not exactly |
| // the same because of rounding issues. |
| if (updated_time > updated_time_submission.time_offset) { |
| updated_time_submission.time_offset = updated_time; |
| } |
| |
| return updated_time_submission; |
| } |
| |
| base::TimeDelta SubmissionQueue::render_time(const base::TimeTicks& time) { |
| if (!renderer_time_origin_) { |
| renderer_time_origin_ = time; |
| } |
| |
| return time - *renderer_time_origin_; |
| } |
| |
| base::TimeDelta SubmissionQueue::submission_time(const base::TimeTicks& time) { |
| return base::TimeDelta::FromMillisecondsD( |
| to_submission_time_in_ms_.GetValueAtTime(time)) + |
| render_time(time); |
| } |
| |
| void SubmissionQueue::PurgeStaleSubmissionsFromQueue( |
| const base::TimeTicks& time) { |
| TRACE_EVENT0("cobalt::renderer", |
| "SubmissionQueue::PurgeStaleSubmissionsFromQueue()"); |
| double current_to_submission_time_in_ms = |
| to_submission_time_in_ms_.GetValueAtTime(time); |
| |
| SubmissionQueueInternal::iterator submission = submission_queue_.end(); |
| --submission; |
| |
| // If there is more than one element in the queue... |
| if (submission != submission_queue_.begin()) { |
| // Skip past the submissions that are in the future. This means we start |
| // from the back because the queue is sorted in ascending order of time. |
| while (current_to_submission_time_in_ms < |
| (submission->time_offset - render_time(time)).InMillisecondsF()) { |
| if (submission == submission_queue_.begin()) { |
| // It is an invariant of this class that the oldest submission in the |
| // queue is older than the current render time. This should be |
| // managed within PushSubmission(). |
| NOTREACHED(); |
| break; |
| } |
| --submission; |
| } |
| } |
| |
| // Delete all previous, old render trees. |
| while (submission_queue_.begin() != submission) { |
| TRACE_EVENT0("cobalt::renderer", "Delete Render Tree Submission"); |
| if (!dispose_function_.is_null()) { |
| // Package the submission for sending to the disposal callback function. |
| // We erase it from our queue before calling the callback in order to |
| // ensure that the callback disposes of the Submission object after we |
| // do. |
| scoped_ptr<Submission> submission( |
| new Submission(submission_queue_.front())); |
| submission_queue_.pop_front(); |
| dispose_function_.Run(submission.Pass()); |
| } else { |
| // If no callback is passed in to dispose of submissions for us, just |
| // delete it immediately. |
| submission_queue_.pop_front(); |
| } |
| } |
| |
| // Update our CVal tracking the current (smoothed) to_submission_time value |
| // and the one tracking submission queue size. |
| to_submission_time_cval_ = base::TimeDelta::FromMilliseconds( |
| to_submission_time_in_ms_.GetValueAtTime(time)); |
| queue_size_ = submission_queue_.size(); |
| } |
| |
| void SubmissionQueue::CheckThatNowIsMonotonicallyIncreasing( |
| const base::TimeTicks& now) { |
| if (last_now_) { |
| DCHECK(now >= *last_now_); |
| } |
| last_now_ = now; |
| } |
| |
| } // namespace renderer |
| } // namespace cobalt |