1 files changed, 102 insertions, 42 deletions

diff --git a/chromium/components/viz/service/surfaces/surface.cc b/chromium/components/viz/service/surfaces/surface.cc
index 9f8a1bc373e..dc9c682da50 100644
--- a/chromium/components/viz/service/surfaces/surface.cc
+++ b/chromium/components/viz/service/surfaces/surface.cc
@@ -15,9 +15,11 @@
 #include "components/viz/common/resources/returned_resource.h"
 #include "components/viz/common/resources/transferable_resource.h"
 #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
+#include "components/viz/service/surfaces/referenced_surface_tracker.h"
 #include "components/viz/service/surfaces/surface_client.h"
 #include "components/viz/service/surfaces/surface_manager.h"
 #include "components/viz/service/viz_service_export.h"
+#include "ui/gfx/presentation_feedback.h"
 
 namespace viz {
 
@@ -28,7 +30,11 @@ Surface::Surface(const SurfaceInfo& surface_info,
     : surface_info_(surface_info),
       surface_manager_(surface_manager),
       surface_client_(std::move(surface_client)),
-      needs_sync_tokens_(needs_sync_tokens) {}
+      needs_sync_tokens_(needs_sync_tokens) {
+  TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("viz.surface_lifetime"),
+                           "Surface", this, "surface_info",
+                           surface_info.ToString());
+}
 
 Surface::~Surface() {
   ClearCopyRequests();
@@ -42,6 +48,10 @@ Surface::~Surface() {
 
   if (deadline_)
     deadline_->Cancel();
+
+  TRACE_EVENT_ASYNC_END1(TRACE_DISABLED_BY_DEFAULT("viz.surface_lifetime"),
+                         "Surface", this, "surface_info",
+                         surface_info_.ToString());
 }
 
 void Surface::SetDependencyDeadline(
@@ -88,12 +98,38 @@ void Surface::UnrefResources(const std::vector<ReturnedResource>& resources) {
     surface_client_->UnrefResources(resources);
 }
 
+void Surface::UpdateSurfaceReferences() {
+  const base::flat_set<SurfaceId>& existing_referenced_surfaces =
+      surface_manager_->GetSurfacesReferencedByParent(surface_id());
+  base::flat_set<SurfaceId> new_referenced_surfaces(
+      active_referenced_surfaces().begin(), active_referenced_surfaces().end(),
+      base::KEEP_FIRST_OF_DUPES);
+
+  // Populate list of surface references to add and remove by getting the
+  // difference between existing surface references and surface references for
+  // latest activated CompositorFrame.
+  std::vector<SurfaceReference> references_to_add;
+  std::vector<SurfaceReference> references_to_remove;
+  GetSurfaceReferenceDifference(surface_id(), existing_referenced_surfaces,
+                                new_referenced_surfaces, &references_to_add,
+                                &references_to_remove);
+
+  // Modify surface references stored in SurfaceManager.
+  if (!references_to_add.empty())
+    surface_manager_->AddSurfaceReferences(references_to_add);
+  if (!references_to_remove.empty())
+    surface_manager_->RemoveSurfaceReferences(references_to_remove);
+}
+
 void Surface::RejectCompositorFramesToFallbackSurfaces() {
   const std::vector<SurfaceId>& activation_dependencies =
       GetPendingFrame().metadata.activation_dependencies;
 
-  for (const SurfaceId& surface_id :
+  for (const SurfaceRange& surface_range :
        GetPendingFrame().metadata.referenced_surfaces) {
+    if (!surface_range.start())
+      continue;
+    const SurfaceId& surface_id = *surface_range.start();
     // A surface ID in |referenced_surfaces| that has a corresponding surface
     // ID in |activation_dependencies| with the same frame sink ID is said to
     // be a fallback surface that can be used in place of the primary surface
@@ -125,33 +161,19 @@ void Surface::Close() {
 bool Surface::QueueFrame(
     CompositorFrame frame,
     uint64_t frame_index,
-    base::OnceClosure callback,
-    const AggregatedDamageCallback& aggregated_damage_callback,
+    base::ScopedClosureRunner frame_rejected_callback,
     PresentedCallback presented_callback) {
   late_activation_dependencies_.clear();
 
   if (frame.size_in_pixels() != surface_info_.size_in_pixels() ||
       frame.device_scale_factor() != surface_info_.device_scale_factor()) {
-    TRACE_EVENT_INSTANT0("cc", "Surface invariants violation",
+    TRACE_EVENT_INSTANT0("viz", "Surface invariants violation",
                          TRACE_EVENT_SCOPE_THREAD);
-    if (presented_callback) {
-      std::move(presented_callback)
-          .Run(base::TimeTicks(), base::TimeDelta(), 0);
-    }
     return false;
   }
 
-  if (closed_) {
-    std::vector<ReturnedResource> resources =
-        TransferableResource::ReturnResources(frame.resource_list);
-    surface_client_->ReturnResources(resources);
-    std::move(callback).Run();
-    if (presented_callback) {
-      std::move(presented_callback)
-          .Run(base::TimeTicks(), base::TimeDelta(), 0);
-    }
+  if (closed_)
     return true;
-  }
 
   if (active_frame_data_ || pending_frame_data_)
     previous_frame_surface_id_ = surface_id();
@@ -172,13 +194,11 @@ bool Surface::QueueFrame(
       (deadline_ && !deadline.deadline_in_frames())) {
     // If there are no blockers, then immediately activate the frame.
     ActivateFrame(
-        FrameData(std::move(frame), frame_index, std::move(callback),
-                  aggregated_damage_callback, std::move(presented_callback)),
+        FrameData(std::move(frame), frame_index, std::move(presented_callback)),
         base::nullopt);
   } else {
     pending_frame_data_ =
-        FrameData(std::move(frame), frame_index, std::move(callback),
-                  aggregated_damage_callback, std::move(presented_callback));
+        FrameData(std::move(frame), frame_index, std::move(presented_callback));
     RejectCompositorFramesToFallbackSurfaces();
 
     // If the deadline is in the past, then we will activate immediately.
@@ -192,6 +212,10 @@ bool Surface::QueueFrame(
   // Returns resources for the previous pending frame.
   UnrefFrameResourcesAndRunCallbacks(std::move(previous_pending_frame_data));
 
+  // The frame should not fail to display beyond this point. Release the
+  // callback so it is not called.
+  (void)frame_rejected_callback.Release();
+
   return true;
 }
 
@@ -264,16 +288,12 @@ void Surface::ActivatePendingFrameForDeadline(
   ActivatePendingFrame(duration);
 }
 
-Surface::FrameData::FrameData(
-    CompositorFrame&& frame,
-    uint64_t frame_index,
-    base::OnceClosure draw_callback,
-    const AggregatedDamageCallback& aggregated_damage_callback,
-    PresentedCallback presented_callback)
+Surface::FrameData::FrameData(CompositorFrame&& frame,
+                              uint64_t frame_index,
+                              PresentedCallback presented_callback)
     : frame(std::move(frame)),
       frame_index(frame_index),
-      draw_callback(std::move(draw_callback)),
-      aggregated_damage_callback(aggregated_damage_callback),
+      frame_processed(false),
       presented_callback(std::move(presented_callback)) {}
 
 Surface::FrameData::FrameData(FrameData&& other) = default;
@@ -319,6 +339,13 @@ void Surface::ActivateFrame(FrameData frame_data,
 
   active_frame_data_ = std::move(frame_data);
 
+  active_referenced_surfaces_.clear();
+  for (SurfaceRange surface_range :
+       active_frame_data_->frame.metadata.referenced_surfaces) {
+    if (surface_range.start())
+      active_referenced_surfaces_.emplace_back(*surface_range.start());
+  }
+
   for (auto& copy_request : old_copy_requests)
     RequestCopyOfOutput(std::move(copy_request));
 
@@ -331,11 +358,25 @@ void Surface::ActivateFrame(FrameData frame_data,
     surface_client_->OnSurfaceActivated(this);
 
   if (!seen_first_frame_activation_) {
+    TRACE_EVENT_WITH_FLOW2(
+        TRACE_DISABLED_BY_DEFAULT("viz.surface_id_flow"),
+        "LocalSurfaceId.Submission.Flow",
+        TRACE_ID_GLOBAL(
+            surface_info_.id().local_surface_id().submission_trace_id()),
+        TRACE_EVENT_FLAG_FLOW_IN, "step", "FirstSurfaceActivation",
+        "surface_id", surface_info_.id().ToString());
+
     seen_first_frame_activation_ = true;
     surface_manager_->FirstSurfaceActivation(surface_info_);
   }
 
   surface_manager_->SurfaceActivated(this, duration);
+
+  // Defer notifying the embedder of an updated token until the frame has been
+  // completely processed.
+  const auto& metadata = GetActiveFrame().metadata;
+  if (surface_client_ && metadata.send_frame_token_to_embedder)
+    surface_client_->OnFrameTokenChanged(metadata.frame_token);
 }
 
 FrameDeadline Surface::UpdateActivationDependencies(
@@ -367,6 +408,14 @@ FrameDeadline Surface::UpdateActivationDependencies(
       if (!track_dependencies)
         continue;
 
+      TRACE_EVENT_WITH_FLOW2(
+          TRACE_DISABLED_BY_DEFAULT("viz.surface_id_flow"),
+          "LocalSurfaceId.Embed.Flow",
+          TRACE_ID_GLOBAL(surface_id.local_surface_id().embed_trace_id()),
+          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT, "step",
+          "AddedActivationDependency", "child_surface_id",
+          surface_id.ToString());
+
       // Record the latest |parent_sequence_number| this surface is interested
       // in observing for the provided FrameSinkId.
       uint32_t& parent_sequence_number =
@@ -483,19 +532,20 @@ bool Surface::TakePresentedCallback(PresentedCallback* callback) {
 }
 
 void Surface::RunDrawCallback() {
-  if (active_frame_data_ && !active_frame_data_->draw_callback.is_null())
-    std::move(active_frame_data_->draw_callback).Run();
+  if (!active_frame_data_ || active_frame_data_->frame_processed)
+    return;
+  active_frame_data_->frame_processed = true;
+  if (surface_client_)
+    surface_client_->OnSurfaceProcessed(this);
 }
 
 void Surface::NotifyAggregatedDamage(const gfx::Rect& damage_rect,
                                      base::TimeTicks expected_display_time) {
-  if (!active_frame_data_ ||
-      active_frame_data_->aggregated_damage_callback.is_null())
+  if (!active_frame_data_ || !surface_client_)
     return;
-
-  active_frame_data_->aggregated_damage_callback.Run(
-      surface_id().local_surface_id(), active_frame_data_->frame, damage_rect,
-      expected_display_time);
+  surface_client_->OnSurfaceAggregatedDamage(
+      this, surface_id().local_surface_id(), active_frame_data_->frame,
+      damage_rect, expected_display_time);
 }
 
 void Surface::OnDeadline(base::TimeDelta duration) {
@@ -516,12 +566,12 @@ void Surface::UnrefFrameResourcesAndRunCallbacks(
     resource.sync_token.Clear();
   surface_client_->UnrefResources(resources);
 
-  if (frame_data->draw_callback)
-    std::move(frame_data->draw_callback).Run();
+  if (!frame_data->frame_processed)
+    surface_client_->OnSurfaceProcessed(this);
 
   if (frame_data->presented_callback) {
     std::move(frame_data->presented_callback)
-        .Run(base::TimeTicks(), base::TimeDelta(), 0);
+        .Run(gfx::PresentationFeedback::Failure());
   }
 }
 
@@ -561,6 +611,16 @@ void Surface::TakeLatencyInfoFromFrame(
 }
 
 void Surface::OnWillBeDrawn() {
+  if (!seen_first_surface_embedding_) {
+    seen_first_surface_embedding_ = true;
+
+    TRACE_EVENT_WITH_FLOW2(
+        TRACE_DISABLED_BY_DEFAULT("viz.surface_id_flow"),
+        "LocalSurfaceId.Embed.Flow",
+        TRACE_ID_GLOBAL(surface_info_.id().local_surface_id().embed_trace_id()),
+        TRACE_EVENT_FLAG_FLOW_IN, "step", "FirstSurfaceEmbedding", "surface_id",
+        surface_info_.id().ToString());
+  }
   surface_manager_->SurfaceWillBeDrawn(this);
 }