cc: Add more info to the BeginMainFrame dump.

cc/scheduler/begin_frame_source.cc

 // 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/scheduler/begin_frame_source.h"
 
 #include <stddef.h>
 
 #include "base/atomic_sequence_num.h"
 #include "base/auto_reset.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/scheduler.h"
 
 namespace cc {
 
 namespace {
 // kDoubleTickDivisor prevents the SyntheticBFS from sending BeginFrames too
 // often to an observer.
 static const double kDoubleTickDivisor = 2.0;
 }
 
 // BeginFrameObserverBase -------------------------------------------------
-BeginFrameObserverBase::BeginFrameObserverBase()
-    : last_begin_frame_args_(), dropped_begin_frame_args_(0) {
-}
+BeginFrameObserverBase::BeginFrameObserverBase() = default;
+
+BeginFrameObserverBase::~BeginFrameObserverBase() = default;
 
 const BeginFrameArgs& BeginFrameObserverBase::LastUsedBeginFrameArgs() const {
   return last_begin_frame_args_;
 }
 
 void BeginFrameObserverBase::OnBeginFrame(const BeginFrameArgs& args) {
   DCHECK(args.IsValid());
   DCHECK(args.frame_time >= last_begin_frame_args_.frame_time);
   DCHECK(args.sequence_number > last_begin_frame_args_.sequence_number ||
          args.source_id != last_begin_frame_args_.source_id)
       << "current " << args.AsValue()->ToString() << ", last "
       << last_begin_frame_args_.AsValue()->ToString();
   bool used = OnBeginFrameDerivedImpl(args);
   if (used) {
     last_begin_frame_args_ = args;
   } else {
     ++dropped_begin_frame_args_;
   }
 }
 
+void BeginFrameObserverBase::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  state->SetInteger("dropped_begin_frame_args", dropped_begin_frame_args_);
+
+  state->BeginDictionary("last_begin_frame_args");
+  last_begin_frame_args_.AsValueInto(state);
+  state->EndDictionary();
+}
+
 // BeginFrameSource -------------------------------------------------------
 namespace {
 static base::StaticAtomicSequenceNumber g_next_source_id;
 }  // namespace
 
 BeginFrameSource::BeginFrameSource() : source_id_(g_next_source_id.GetNext()) {}
 
-uint32_t BeginFrameSource::source_id() const {
-  return source_id_;
+BeginFrameSource::~BeginFrameSource() = default;
+
+void BeginFrameSource::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  state->SetInteger("source_id", source_id_);
 }
 
 // StubBeginFrameSource ---------------------------------------------------
 bool StubBeginFrameSource::IsThrottled() const {
   return true;
 }
 
 // SyntheticBeginFrameSource ----------------------------------------------
 SyntheticBeginFrameSource::~SyntheticBeginFrameSource() = default;
 
@@ skipping 162 matching lines @@
     if (!last_args.IsValid() ||
         (current_begin_frame_args_.frame_time >
          last_args.frame_time +
              current_begin_frame_args_.interval / kDoubleTickDivisor)) {
       obs->OnBeginFrame(current_begin_frame_args_);
     }
   }
 }
 
 // BeginFrameObserverAckTracker -------------------------------------------
-BeginFrameObserverAckTracker::BeginFrameObserverAckTracker()
-    : current_source_id_(0),
-      current_sequence_number_(BeginFrameArgs::kStartingFrameNumber),
-      observers_had_damage_(false) {}
+BeginFrameObserverAckTracker::BeginFrameObserverAckTracker() = default;
 
-BeginFrameObserverAckTracker::~BeginFrameObserverAckTracker() {}
+BeginFrameObserverAckTracker::~BeginFrameObserverAckTracker() = default;
 
 void BeginFrameObserverAckTracker::OnBeginFrame(const BeginFrameArgs& args) {
   if (current_source_id_ != args.source_id)
     SourceChanged(args);
 
   DCHECK_GE(args.sequence_number, current_sequence_number_);
   // Reset for new BeginFrame.
   current_sequence_number_ = args.sequence_number;
   finished_observers_.clear();
   observers_had_damage_ = false;
@@ skipping 67 matching lines @@
 
 uint64_t BeginFrameObserverAckTracker::LatestConfirmedSequenceNumber() const {
   uint64_t latest_confirmed_sequence_number = current_sequence_number_;
   for (const auto& entry : latest_confirmed_sequence_numbers_) {
     latest_confirmed_sequence_number =
         std::min(latest_confirmed_sequence_number, entry.second);
   }
   return latest_confirmed_sequence_number;
 }
 
+void BeginFrameObserverAckTracker::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  base::SmallMap<std::map<BeginFrameObserver*, uint64_t>, 4>
+      latest_confirmed_sequence_numbers_;
+  state->SetInteger("current_source_id", current_source_id_);
+  state->SetInteger("current_sequence_number", current_sequence_number_);
+  state->SetInteger("num_observers", observers_.size());
+  state->SetInteger("num_finished_observers", finished_observers_.size());
+  state->SetBoolean("observers_had_damage", observers_had_damage_);
+
+  state->BeginArray("latest_confirmed_sequence_numbers");
+  for (const auto& kv : latest_confirmed_sequence_numbers_) {
+    state->AppendInteger(kv.second);
+  }
+  state->EndArray();
+}
+
 // ExternalBeginFrameSource -----------------------------------------------
 ExternalBeginFrameSource::ExternalBeginFrameSource(
     ExternalBeginFrameSourceClient* client)
     : client_(client) {
   DCHECK(client_);
 }
 
 ExternalBeginFrameSource::~ExternalBeginFrameSource() = default;
 
+void ExternalBeginFrameSource::AsValueInto(
+    base::trace_event::TracedValue* state) const {
+  BeginFrameSource::AsValueInto(state);
+
+  state->SetBoolean("paused", paused_);
+  state->SetBoolean("frame_active", frame_active_);
+  state->SetInteger("num_observers", observers_.size());
+
+  state->BeginDictionary("last_begin_frame_args");
+  last_begin_frame_args_.AsValueInto(state);
+  state->EndDictionary();
+
+  state->BeginDictionary("ack_tracker_state");
+  ack_tracker_.AsValueInto(state);
+  state->EndDictionary();
+}
+
 void ExternalBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(observers_.find(obs) == observers_.end());
 
   bool observers_was_empty = observers_.empty();
   observers_.insert(obs);
   ack_tracker_.OnObserverAdded(obs);
   obs->OnBeginFrameSourcePausedChanged(paused_);
   if (observers_was_empty)
     client_->OnNeedsBeginFrames(true);
 
   // Send a MISSED begin frame if necessary.
-  if (missed_begin_frame_args_.IsValid()) {
+  if (last_begin_frame_args_.IsValid()) {
     const BeginFrameArgs& last_args = obs->LastUsedBeginFrameArgs();
     if (!last_args.IsValid() ||
-        (missed_begin_frame_args_.frame_time > last_args.frame_time)) {
-      DCHECK((missed_begin_frame_args_.source_id != last_args.source_id) ||
-             (missed_begin_frame_args_.sequence_number >
-              last_args.sequence_number))
-          << "current " << missed_begin_frame_args_.AsValue()->ToString()
+        (last_begin_frame_args_.frame_time > last_args.frame_time)) {
+      DCHECK(
+          (last_begin_frame_args_.source_id != last_args.source_id) ||
+          (last_begin_frame_args_.sequence_number > last_args.sequence_number))
+          << "current " << last_begin_frame_args_.AsValue()->ToString()
           << ", last " << last_args.AsValue()->ToString();
-      obs->OnBeginFrame(missed_begin_frame_args_);
+      BeginFrameArgs missed_args = last_begin_frame_args_;
+      missed_args.type = BeginFrameArgs::MISSED;
+      obs->OnBeginFrame(missed_args);
     }
   }
 }
 
 void ExternalBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
   DCHECK(obs);
   DCHECK(observers_.find(obs) != observers_.end());
 
   observers_.erase(obs);
   ack_tracker_.OnObserverRemoved(obs);
   MaybeFinishFrame();
   if (observers_.empty()) {
-    missed_begin_frame_args_ = BeginFrameArgs();
+    last_begin_frame_args_ = BeginFrameArgs();
     client_->OnNeedsBeginFrames(false);
   }
 }
 
 void ExternalBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs,
                                               const BeginFrameAck& ack) {
   ack_tracker_.OnObserverFinishedFrame(obs, ack);
   MaybeFinishFrame();
 }
 
 bool ExternalBeginFrameSource::IsThrottled() const {
   return true;
 }
 
 void ExternalBeginFrameSource::OnSetBeginFrameSourcePaused(bool paused) {
   if (paused_ == paused)
     return;
   paused_ = paused;
   std::unordered_set<BeginFrameObserver*> observers(observers_);
   for (auto* obs : observers)
     obs->OnBeginFrameSourcePausedChanged(paused_);
 }
 
 void ExternalBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) {
   if (frame_active_)
     FinishFrame();
 
   frame_active_ = true;
-  missed_begin_frame_args_ = args;
-  missed_begin_frame_args_.type = BeginFrameArgs::MISSED;
+  last_begin_frame_args_ = args;

[sunnyps, 2017/04/14 23:24:11]

NOTE: I don't set type to MISSED here because I want to dump what the incoming
args are. The type is set to MISSED before the args are sent as missed args to
an observer (see AddObserver).

   ack_tracker_.OnBeginFrame(args);
   std::unordered_set<BeginFrameObserver*> observers(observers_);
   for (auto* obs : observers) {
     // It is possible that the source in which |args| originate changes, or that
     // our hookup to this source changes, so we have to check for continuity.
     // See also https://crbug.com/690127 for what may happen without this check.
     const BeginFrameArgs& last_args = obs->LastUsedBeginFrameArgs();
     if (!last_args.IsValid() || (args.frame_time > last_args.frame_time)) {
       DCHECK((args.source_id != last_args.source_id) ||
              (args.sequence_number > last_args.sequence_number))
           << "current " << args.AsValue()->ToString() << ", last "
           << last_args.AsValue()->ToString();
       obs->OnBeginFrame(args);
     }
   }
   MaybeFinishFrame();
 }
 
 void ExternalBeginFrameSource::MaybeFinishFrame() {
   if (!frame_active_ || !ack_tracker_.AllObserversFinishedFrame())
     return;
   FinishFrame();
 }
 
 void ExternalBeginFrameSource::FinishFrame() {
   frame_active_ = false;
 
-  BeginFrameAck ack(missed_begin_frame_args_.source_id,
-                    missed_begin_frame_args_.sequence_number,
+  BeginFrameAck ack(last_begin_frame_args_.source_id,
+                    last_begin_frame_args_.sequence_number,
                     ack_tracker_.LatestConfirmedSequenceNumber(),
                     ack_tracker_.AnyObserversHadDamage());
   client_->OnDidFinishFrame(ack);
 }
 
 }  // namespace cc