[exo]CompositorFrameSinkHolder calls WillDraw in DidReceiveCompositorFrameAck

components/exo/surface.cc

 // Copyright 2015 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 "components/exo/surface.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 446 matching lines @@
 
     UpdateResource(true);
   }
 
   cc::LocalSurfaceId old_local_surface_id = local_surface_id_;
   if (needs_commit_to_new_surface_ || !local_surface_id_.is_valid()) {
     needs_commit_to_new_surface_ = false;
     local_surface_id_ = id_allocator_.GenerateId();
   }
 
+  // Move pending frame callbacks to the end of frame_callbacks_.
+  frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
+
+  // Move pending presentation callbacks to the end of presentation_callbacks_.
+  presentation_callbacks_.splice(presentation_callbacks_.end(),
+                                 pending_presentation_callbacks_);
+
   UpdateSurface(false);
 
   if (old_local_surface_id != local_surface_id_) {
     float contents_surface_to_layer_scale = 1.0;
     // The bounds must be updated before switching to the new surface, because
     // the layer may be mirrored, in which case a surface change causes the
     // mirror layer to update its surface using the latest bounds.
     window_->layer()->SetBounds(
         gfx::Rect(window_->layer()->bounds().origin(), content_size_));
     cc::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
     window_->layer()->SetShowPrimarySurface(
         cc::SurfaceInfo(surface_id, contents_surface_to_layer_scale,
                         content_size_),
         surface_reference_factory_);
     window_->layer()->SetFillsBoundsOpaquely(
         !current_resource_has_alpha_ ||
         state_.blend_mode == SkBlendMode::kSrc ||
         state_.opaque_region.contains(
             gfx::RectToSkIRect(gfx::Rect(content_size_))));
   }
 
   // Reset damage.
   pending_damage_.setEmpty();
 
   DCHECK(!current_resource_.id ||
          compositor_frame_sink_holder_->HasReleaseCallbackForResource(
              current_resource_.id));
 
-  // Move pending frame callbacks to the end of frame_callbacks_.
-  frame_callbacks_.splice(frame_callbacks_.end(), pending_frame_callbacks_);
-
-  // Move pending presentation callbacks to the end of presentation_callbacks_.
-  presentation_callbacks_.splice(presentation_callbacks_.end(),
-                                 pending_presentation_callbacks_);
-
   // Synchronize window hierarchy. This will position and update the stacking
   // order of all sub-surfaces after committing all pending state of sub-surface
   // descendants.
   aura::Window* stacking_target = nullptr;
   for (auto& sub_surface_entry : pending_sub_surfaces_) {
     Surface* sub_surface = sub_surface_entry.first;
 
     // Synchronsouly commit all pending state of the sub-surface and its
     // decendents.
     if (sub_surface->needs_commit_surface_hierarchy())
@@ skipping 86 matching lines @@
   return observers_.HasObserver(observer);
 }
 
 std::unique_ptr<base::trace_event::TracedValue> Surface::AsTracedValue() const {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
   value->SetString("name", window_->layer()->name());
   return value;
 }
 
-void Surface::WillDraw() {
+void Surface::DidReceiveCompositorFrameAck() {
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  frame_callbacks_);
   swapping_presentation_callbacks_.splice(
       swapping_presentation_callbacks_.end(), presentation_callbacks_);
   UpdateNeedsBeginFrame();
 }
 
 void Surface::SetBeginFrameSource(cc::BeginFrameSource* begin_frame_source) {
   if (needs_begin_frame_) {
     DCHECK(begin_frame_source_);
@@ skipping 257 matching lines @@
         render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
     solid_quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorBLACK, false);
   }
 
   frame.render_pass_list.push_back(std::move(render_pass));
   compositor_frame_sink_holder_->GetCompositorFrameSink()
       ->SubmitCompositorFrame(local_surface_id_, std::move(frame));
 }
 
 }  // namespace exo