OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "cc/surfaces/display_begin_frame_source.h" |
| 6 |
| 7 #include <algorithm> |
| 8 |
| 9 namespace cc { |
| 10 |
| 11 DisplayBeginFrameSource::DisplayBeginFrameSource( |
| 12 std::unique_ptr<BeginFrameSource> wrapped_source) |
| 13 : wrapped_source_(std::move(wrapped_source)), |
| 14 observing_begin_frames_(false), |
| 15 frame_active_(false), |
| 16 current_source_id_(0), |
| 17 oldest_incorporated_frame_(0), |
| 18 client_(nullptr), |
| 19 client_needs_begin_frames_(false) {} |
| 20 |
| 21 DisplayBeginFrameSource::~DisplayBeginFrameSource() { |
| 22 if (wrapped_source_ && observing_begin_frames_) |
| 23 wrapped_source_->RemoveObserver(this); |
| 24 } |
| 25 |
| 26 void DisplayBeginFrameSource::SetClient(DisplayBeginFrameSourceClient* client) { |
| 27 client_ = client; |
| 28 ObserverStatusChanged(); |
| 29 } |
| 30 |
| 31 void DisplayBeginFrameSource::SetClientNeedsBeginFrames( |
| 32 bool needs_begin_frames) { |
| 33 DCHECK(client_); |
| 34 |
| 35 if (client_needs_begin_frames_ == needs_begin_frames) |
| 36 return; |
| 37 client_needs_begin_frames_ = needs_begin_frames; |
| 38 |
| 39 if (client_needs_begin_frames_ && observing_begin_frames_) { |
| 40 // We were already observing, but the client may have missed the last |
| 41 // BeginFrame. |
| 42 BeginFrameArgs missed_args = |
| 43 GetMissedArgs(client_->LastUsedBeginFrameArgs()); |
| 44 if (missed_args.IsValid()) |
| 45 client_->OnBeginFrame(missed_args); |
| 46 } |
| 47 |
| 48 UpdateObservingBeginFrames(); |
| 49 } |
| 50 |
| 51 void DisplayBeginFrameSource::FinishClientFrame(bool had_updates, |
| 52 bool has_pending_updates) { |
| 53 DCHECK(frame_active_); |
| 54 frame_active_ = false; |
| 55 |
| 56 // Only update the oldest_incorporated_frame if there are no further pending |
| 57 // updates (i.e. the Display didn't have to draw or drew successfully). |
| 58 if (!has_pending_updates) |
| 59 oldest_incorporated_frame_ = ack_tracker_.OldestIncorporatedFrame(); |
| 60 |
| 61 BeginFrameAck ack(current_begin_frame_args_.source_id, |
| 62 current_begin_frame_args_.sequence_number, |
| 63 oldest_incorporated_frame_, 0, had_updates); |
| 64 if (wrapped_source_) |
| 65 wrapped_source_->DidFinishFrame(this, ack); |
| 66 } |
| 67 |
| 68 bool DisplayBeginFrameSource::HasObservers() const { |
| 69 return !observers_.empty(); |
| 70 } |
| 71 |
| 72 bool DisplayBeginFrameSource::AllObserversFinishedFrame() const { |
| 73 return ack_tracker_.AllObserversFinishedFrame(); |
| 74 } |
| 75 |
| 76 void DisplayBeginFrameSource::SwapWrappedSource( |
| 77 std::unique_ptr<BeginFrameSource>* begin_frame_source) { |
| 78 if (wrapped_source_ && observing_begin_frames_) |
| 79 wrapped_source_->RemoveObserver(this); |
| 80 |
| 81 wrapped_source_.swap(*begin_frame_source); |
| 82 |
| 83 if (wrapped_source_ && observing_begin_frames_) |
| 84 wrapped_source_->AddObserver(this); |
| 85 } |
| 86 |
| 87 void DisplayBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs, |
| 88 const BeginFrameAck& ack) { |
| 89 ack_tracker_.OnObserverFinishedFrame(obs, ack); |
| 90 ObserverStatusChanged(); |
| 91 } |
| 92 |
| 93 void DisplayBeginFrameSource::AddObserver(BeginFrameObserver* obs) { |
| 94 observers_.insert(obs); |
| 95 ack_tracker_.OnObserverAdded(obs); |
| 96 |
| 97 if (observing_begin_frames_) { |
| 98 // We were already observing, but the observer may have missed the last |
| 99 // BeginFrame. |
| 100 BeginFrameArgs missed_args = GetMissedArgs(obs->LastUsedBeginFrameArgs()); |
| 101 if (missed_args.IsValid()) { |
| 102 obs->OnBeginFrame(missed_args); |
| 103 ack_tracker_.OnObserverBeginFrame(obs, missed_args); |
| 104 } |
| 105 } |
| 106 |
| 107 UpdateObservingBeginFrames(); |
| 108 ObserverStatusChanged(); |
| 109 } |
| 110 |
| 111 void DisplayBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { |
| 112 observers_.erase(obs); |
| 113 ack_tracker_.OnObserverRemoved(obs); |
| 114 |
| 115 UpdateObservingBeginFrames(); |
| 116 ObserverStatusChanged(); |
| 117 } |
| 118 |
| 119 bool DisplayBeginFrameSource::IsThrottled() const { |
| 120 if (wrapped_source_) |
| 121 return wrapped_source_->IsThrottled(); |
| 122 return true; |
| 123 } |
| 124 |
| 125 void DisplayBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) { |
| 126 if (client_ && client_needs_begin_frames_) |
| 127 client_->OnBeginFrame(args); |
| 128 |
| 129 // Reset for the new frame. |
| 130 frame_active_ = true; |
| 131 ack_tracker_.OnBeginFrame(args); |
| 132 |
| 133 // BeginFrameObserverAckTracker will have updated the oldest incorporated |
| 134 // frame if the wrapped source changes. |
| 135 if (args.source_id != current_source_id_) |
| 136 oldest_incorporated_frame_ = ack_tracker_.OldestIncorporatedFrame(); |
| 137 |
| 138 current_begin_frame_args_ = args; |
| 139 |
| 140 // Observers may remove themselves during OnBeginFrame(), so use a copy. |
| 141 std::set<BeginFrameObserver*> observers = observers_; |
| 142 for (BeginFrameObserver* obs : observers) { |
| 143 obs->OnBeginFrame(args); |
| 144 ack_tracker_.OnObserverBeginFrame(obs, args); |
| 145 } |
| 146 |
| 147 ObserverStatusChanged(); |
| 148 } |
| 149 |
| 150 const BeginFrameArgs& DisplayBeginFrameSource::LastUsedBeginFrameArgs() const { |
| 151 return current_begin_frame_args_; |
| 152 } |
| 153 |
| 154 void DisplayBeginFrameSource::OnBeginFrameSourcePausedChanged(bool paused) { |
| 155 // BeginFrameSources used as wrapped sources do not make use of this feature. |
| 156 DCHECK(!paused); |
| 157 } |
| 158 |
| 159 void DisplayBeginFrameSource::UpdateObservingBeginFrames() { |
| 160 bool should_observe = client_needs_begin_frames_ || !observers_.empty(); |
| 161 if (should_observe == observing_begin_frames_) |
| 162 return; |
| 163 |
| 164 observing_begin_frames_ = should_observe; |
| 165 |
| 166 if (!wrapped_source_) |
| 167 return; |
| 168 |
| 169 if (observing_begin_frames_) { |
| 170 // We need to start observing, a missed BeginFrame will be triggered by |
| 171 // the wrapped source and forwarded to the client or observer. |
| 172 wrapped_source_->AddObserver(this); |
| 173 } else { |
| 174 wrapped_source_->RemoveObserver(this); |
| 175 } |
| 176 } |
| 177 |
| 178 BeginFrameArgs DisplayBeginFrameSource::GetMissedArgs( |
| 179 const BeginFrameArgs& last_args) const { |
| 180 if (!current_begin_frame_args_.IsValid() || !wrapped_source_ || |
| 181 !frame_active_) |
| 182 return BeginFrameArgs(); |
| 183 |
| 184 if (last_args.IsValid() && |
| 185 (last_args.sequence_number >= current_begin_frame_args_.sequence_number)) |
| 186 return BeginFrameArgs(); |
| 187 |
| 188 BeginFrameArgs missed_args = current_begin_frame_args_; |
| 189 missed_args.type = BeginFrameArgs::MISSED; |
| 190 return missed_args; |
| 191 } |
| 192 |
| 193 void DisplayBeginFrameSource::ObserverStatusChanged() { |
| 194 if (client_) |
| 195 client_->BeginFrameObserverStatusChanged(); |
| 196 } |
| 197 |
| 198 } // namespace cc |
OLD | NEW |