cc: Introduce BeginFrame sequence numbers and acknowledgements.

cc/surfaces/display.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/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/gl_renderer.h"
+#include "cc/output/output_surface_frame.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/output/software_renderer.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/display_client.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_aggregator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
@@ skipping 10 matching lines @@
                  const RendererSettings& settings,
                  const FrameSinkId& frame_sink_id,
                  std::unique_ptr<BeginFrameSource> begin_frame_source,
                  std::unique_ptr<OutputSurface> output_surface,
                  std::unique_ptr<DisplayScheduler> scheduler,
                  std::unique_ptr<TextureMailboxDeleter> texture_mailbox_deleter)
     : bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       settings_(settings),
       frame_sink_id_(frame_sink_id),
-      begin_frame_source_(std::move(begin_frame_source)),
+      begin_frame_source_(
+          new DisplayBeginFrameSource(std::move(begin_frame_source))),
       output_surface_(std::move(output_surface)),
       scheduler_(std::move(scheduler)),
       texture_mailbox_deleter_(std::move(texture_mailbox_deleter)) {
   DCHECK(output_surface_);
-  DCHECK_EQ(!scheduler_, !begin_frame_source_);
+  DCHECK_EQ(!scheduler_, !begin_frame_source_->GetWrappedSource());
   DCHECK(frame_sink_id_.is_valid());
-  if (scheduler_)
+  if (scheduler_) {
     scheduler_->SetClient(this);
+    scheduler_->SetBeginFrameSource(begin_frame_source_.get());
+  }
 }
 
 Display::~Display() {
   // Only do this if Initialize() happened.
   if (client_) {
     if (auto* context = output_surface_->context_provider())
       context->SetLostContextCallback(base::Closure());
-    if (begin_frame_source_)
-      surface_manager_->UnregisterBeginFrameSource(begin_frame_source_.get());
+    surface_manager_->UnregisterBeginFrameSource(begin_frame_source_.get());
     surface_manager_->RemoveObserver(this);
   }
   if (aggregator_) {
     for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
       Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
       if (surface)
         surface->RunDrawCallbacks();
     }
   }
 }
 
 void Display::Initialize(DisplayClient* client,
                          SurfaceManager* surface_manager) {
   DCHECK(client);
   DCHECK(surface_manager);
   client_ = client;
   surface_manager_ = surface_manager;
 
   surface_manager_->AddObserver(this);
 
   // This must be done in Initialize() so that the caller can delay this until
   // they are ready to receive a BeginFrameSource.
-  if (begin_frame_source_) {
-    surface_manager_->RegisterBeginFrameSource(begin_frame_source_.get(),
-                                               frame_sink_id_);
-  }
+  surface_manager_->RegisterBeginFrameSource(begin_frame_source_.get(),
+                                             frame_sink_id_);
 
   output_surface_->BindToClient(this);
   InitializeRenderer();
 
   if (auto* context = output_surface_->context_provider()) {
     // This depends on assumptions that Display::Initialize will happen
     // on the same callstack as the ContextProvider being created/initialized
     // or else it could miss a callback before setting this.
     context->SetLostContextCallback(base::Bind(
         &Display::DidLoseContextProvider,
@@ skipping 222 matching lines @@
   if (should_swap) {
     swapped_since_resize_ = true;
     for (auto& latency : frame.metadata.latency_info) {
       TRACE_EVENT_WITH_FLOW1(
           "input,benchmark", "LatencyInfo.Flow",
           TRACE_ID_DONT_MANGLE(latency.trace_id()),
           TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT, "step",
           "Display::DrawAndSwap");
     }
     benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
-    renderer_->SwapBuffers(std::move(frame.metadata.latency_info));
+    OutputSurfaceFrame output_frame;
+    output_frame.latency_info = std::move(frame.metadata.latency_info);
+    // Pass on frame number information through |output_frame| for output
+    // surfaces that acknowledge the frame to an external BeginFrameSource.
+    output_frame.begin_frame_source_id = begin_frame_source_->CurrentSourceId();
+    output_frame.begin_frame_number = begin_frame_source_->CurrentFrameNumber();
+    output_frame.begin_frame_number =
+        begin_frame_source_->LatestConfirmedFrame();
+    renderer_->SwapBuffers(std::move(output_frame));
     if (scheduler_)
       scheduler_->DidSwapBuffers();
   } else {
     if (have_damage && !size_matches)
       aggregator_->SetFullDamageForSurface(current_surface_id_);
     TRACE_EVENT_INSTANT0("cc", "Swap skipped.", TRACE_EVENT_SCOPE_THREAD);
     stored_latency_info_.insert(stored_latency_info_.end(),
                                 frame.metadata.latency_info.begin(),
                                 frame.metadata.latency_info.end());
     if (scheduler_) {
@@ skipping 54 matching lines @@
 
 const SurfaceId& Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 void Display::ForceImmediateDrawAndSwapIfPossible() {
   if (scheduler_)
     scheduler_->ForceImmediateSwapIfPossible();
 }
 
+void Display::SwapBeginFrameSource(
+    std::unique_ptr<BeginFrameSource>* begin_frame_source) {
+  begin_frame_source_->SwapWrappedSource(begin_frame_source);
+}
+
 }  // namespace cc