[cc] Plumb BeginFrameAcks through SurfaceManager to DisplayScheduler.

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/metrics/histogram_macros.h"
@@ skipping 43 matching lines @@
   DCHECK(frame_sink_id_.is_valid());
   if (scheduler_) {
     scheduler_->SetClient(this);
     scheduler_->SetBeginFrameSource(begin_frame_source);
   }
 }
 
 Display::~Display() {
   // Only do this if Initialize() happened.
   if (client_) {
+    scheduler_->SetSurfaceManager(nullptr);
     if (auto* context = output_surface_->context_provider())
       context->SetLostContextCallback(base::Closure());
     if (begin_frame_source_)
       surface_manager_->UnregisterBeginFrameSource(begin_frame_source_);
     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)
@@ skipping 14 matching lines @@
   // 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_,
                                                frame_sink_id_);
   }
 
   output_surface_->BindToClient(this);
   InitializeRenderer();
 
+  if (scheduler_)
+    scheduler_->SetSurfaceManager(surface_manager_);
+
   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,
         // Unretained is safe since the callback is unset in this class'
         // destructor and is never posted.
         base::Unretained(this)));
   }
@@ skipping 253 matching lines @@
     if (scheduler_) {
       scheduler_->DidSwapBuffers();
       scheduler_->DidReceiveSwapBuffersAck();
     }
   }
 
   client_->DisplayDidDrawAndSwap();
   return true;
 }
 
+const SurfaceAggregator::SurfaceIndexMap&
+Display::GetPreviousContainedSurfaces() {
+  DCHECK(aggregator_);
+  return aggregator_->previous_contained_surfaces();
+}
+
 void Display::DidReceiveSwapBuffersAck() {
   if (scheduler_)
     scheduler_->DidReceiveSwapBuffersAck();
   if (renderer_)
     renderer_->SwapBuffersComplete();
 }
 
 void Display::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
   if (renderer_)
@@ skipping 22 matching lines @@
   } else if (surface_id == current_surface_id_) {
     if (scheduler_)
       scheduler_->SurfaceDamaged(surface_id);
     *changed = true;
   }
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
-void Display::OnSurfaceCreated(const SurfaceInfo& surface_info) {}
+void Display::OnSurfaceCreated(const SurfaceInfo& surface_info) {
+  if (scheduler_)
+    scheduler_->SurfaceCreated(surface_info);
+}
+
+void Display::OnSurfaceDestroyed(const SurfaceId& surface_id) {
+  if (scheduler_)
+    scheduler_->SurfaceDestroyed(surface_id);
+}
+
+void Display::OnSurfaceReceivedBeginFrame(const SurfaceId& surface_id,
+                                          const BeginFrameArgs& args) {
+  if (scheduler_)
+    scheduler_->SurfaceReceivedBeginFrame(surface_id, args);
+}
+void Display::OnSurfaceFinishedBeginFrame(const SurfaceId& surface_id,
+                                          const BeginFrameAck& ack) {
+  if (scheduler_)
+    scheduler_->SurfaceFinishedBeginFrame(surface_id, ack);
+}
 
 const SurfaceId& Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 void Display::ForceImmediateDrawAndSwapIfPossible() {
   if (scheduler_)
     scheduler_->ForceImmediateSwapIfPossible();
 }
 
 }  // namespace cc