viz: Refactor RemapPassId into a separate class.

This patch refactors SurfaceAggregator::RemapPassId into a separate
class. The intent of this is to clean up the code a bit, and to allow
the remapper to be extended in the future by allowing persistent ids
for certain render passes.

R=kylechar@chromium.org, weiliangc@chromium.org
Bug: 1106418

Change-Id: I4ffffd15dd4fcd6a51df88f4d14666a5ff320d52
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2280262
Commit-Queue: vmpstr <vmpstr@chromium.org>
Reviewed-by: weiliangc <weiliangc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789148}

components/viz/service/BUILD.gn

@@ -66,6 +66,8 @@ viz_component("service") {
     "display/overlay_processor_stub.h",
     "display/program_binding.cc",
     "display/program_binding.h",
+    "display/render_pass_id_remapper.cc",
+    "display/render_pass_id_remapper.h",
     "display/renderer_utils.cc",
     "display/renderer_utils.h",
     "display/resource_fence.h",

components/viz/service/display/render_pass_id_remapper.cc

+// Copyright 2020 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/viz/service/display/render_pass_id_remapper.h"
+
+#include <utility>
+
+#include "base/containers/flat_map.h"
+#include "components/viz/common/quads/render_pass.h"
+#include "components/viz/common/surfaces/surface_id.h"
+
+namespace viz {
+
+RenderPassIdRemapper::RenderPassIdRemapper() = default;
+
+RenderPassIdRemapper::~RenderPassIdRemapper() = default;
+
+RenderPassId RenderPassIdRemapper::Remap(RenderPassId surface_local_pass_id,
+                                         const SurfaceId& surface_id) {
+  auto key = std::make_pair(surface_id, surface_local_pass_id);
+  auto it = render_pass_allocator_map_.find(key);
+  if (it != render_pass_allocator_map_.end()) {
+    it->second.in_use = true;
+    return it->second.id;
+  }
+
+  RenderPassInfo render_pass_info;
+  render_pass_info.id = NextAvailableId();
+  render_pass_allocator_map_[key] = render_pass_info;
+  return render_pass_info.id;
+}
+
+RenderPassId RenderPassIdRemapper::NextAvailableId() {
+  return next_render_pass_id_++;
+}
+
+void RenderPassIdRemapper::ClearUnusedMappings() {
+  // Remove all render pass mappings that weren't used in the current frame.
+  for (auto it = render_pass_allocator_map_.begin();
+       it != render_pass_allocator_map_.end();) {
+    if (it->second.in_use) {
+      it->second.in_use = false;
+      it++;
+    } else {
+      it = render_pass_allocator_map_.erase(it);
+    }
+  }
+}
+
+}  // namespace viz

components/viz/service/display/render_pass_id_remapper.h

+// Copyright 2020 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.
+
+#ifndef COMPONENTS_VIZ_SERVICE_DISPLAY_RENDER_PASS_ID_REMAPPER_H_
+#define COMPONENTS_VIZ_SERVICE_DISPLAY_RENDER_PASS_ID_REMAPPER_H_
+
+#include <utility>
+
+#include "base/containers/flat_map.h"
+#include "components/viz/common/quads/render_pass.h"
+#include "components/viz/common/surfaces/surface_id.h"
+
+namespace viz {
+
+// A class responsible for remapping surface namespace render pass ids to a
+// global namespace to avoid collisions.
+class RenderPassIdRemapper {
+ public:
+  RenderPassIdRemapper();
+  RenderPassIdRemapper(const RenderPassIdRemapper&) = delete;
+  ~RenderPassIdRemapper();
+
+  RenderPassIdRemapper& operator=(const RenderPassIdRemapper&) = delete;
+
+  RenderPassId Remap(RenderPassId surface_local_pass_id,
+                     const SurfaceId& surface_id);
+  RenderPassId NextAvailableId();
+
+  void ClearUnusedMappings();
+
+ private:
+  struct RenderPassInfo {
+    // This is the id the pass is mapped to.
+    int id;
+    // This is true if the pass was used in the last aggregated frame.
+    bool in_use = true;
+  };
+
+  base::flat_map<std::pair<SurfaceId, RenderPassId>, RenderPassInfo>
+      render_pass_allocator_map_;
+  RenderPassId next_render_pass_id_ = 1;
+};
+
+}  // namespace viz
+
+#endif  // COMPONENTS_VIZ_SERVICE_DISPLAY_RENDER_PASS_ID_REMAPPER_H_

components/viz/service/display/surface_aggregator.cc

@@ -136,7 +136,6 @@ SurfaceAggregator::SurfaceAggregator(SurfaceManager* manager,
                                      bool needs_surface_occluding_damage_rect)
     : manager_(manager),
       provider_(provider),
-      next_render_pass_id_(1),
       aggregate_only_damaged_(aggregate_only_damaged),
       needs_surface_occluding_damage_rect_(needs_surface_occluding_damage_rect),
       de_jelly_enabled_(DeJellyEnabled()) {
@@ -199,21 +198,6 @@ SurfaceAggregator::ClipData SurfaceAggregator::CalculateClipRect(
   return out_clip;
 }
 
-RenderPassId SurfaceAggregator::RemapPassId(RenderPassId surface_local_pass_id,
-                                            const SurfaceId& surface_id) {
-  auto key = std::make_pair(surface_id, surface_local_pass_id);
-  auto it = render_pass_allocator_map_.find(key);
-  if (it != render_pass_allocator_map_.end()) {
-    it->second.in_use = true;
-    return it->second.id;
-  }
-
-  RenderPassInfo render_pass_info;
-  render_pass_info.id = next_render_pass_id_++;
-  render_pass_allocator_map_[key] = render_pass_info;
-  return render_pass_info.id;
-}
-
 int SurfaceAggregator::ChildIdForSurface(Surface* surface) {
   auto it = surface_id_to_resource_child_id_.find(surface->surface_id());
   if (it == surface_id_to_resource_child_id_.end()) {
@@ -560,7 +544,8 @@ void SurfaceAggregator::EmitSurfaceContent(
     std::unique_ptr<RenderPass> copy_pass(
         RenderPass::Create(sqs_size, dq_size));
 
-    RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
+    RenderPassId remapped_pass_id =
+        pass_id_remapper_.Remap(source.id, surface_id);
 
     gfx::Rect output_rect = source.output_rect;
     if (max_texture_size_ > 0) {
@@ -685,7 +670,8 @@ void SurfaceAggregator::EmitSurfaceContent(
     // We can't produce content outside of |quad_rect|, so clip the visible
     // rect if necessary.
     quad_visible_rect.Intersect(quad_rect);
-    RenderPassId remapped_pass_id = RemapPassId(last_pass.id, surface_id);
+    RenderPassId remapped_pass_id =
+        pass_id_remapper_.Remap(last_pass.id, surface_id);
     if (quad_visible_rect.IsEmpty()) {
       dest_pass_list_->erase(
           std::remove_if(
@@ -821,7 +807,7 @@ void SurfaceAggregator::AddColorConversionPass() {
   CHECK(root_render_pass->transform_to_root_target == gfx::Transform());
 
   if (!color_conversion_render_pass_id_)
-    color_conversion_render_pass_id_ = next_render_pass_id_++;
+    color_conversion_render_pass_id_ = pass_id_remapper_.NextAvailableId();
 
   auto color_conversion_pass = RenderPass::Create(1, 1);
   color_conversion_pass->SetNew(color_conversion_render_pass_id_, output_rect,
@@ -861,7 +847,7 @@ void SurfaceAggregator::AddDisplayTransformPass() {
   DCHECK(root_render_pass->transform_to_root_target == root_surface_transform_);
 
   if (!display_transform_render_pass_id_)
-    display_transform_render_pass_id_ = next_render_pass_id_++;
+    display_transform_render_pass_id_ = pass_id_remapper_.NextAvailableId();
 
   auto display_transform_pass = RenderPass::Create(1, 1);
   display_transform_pass->SetAll(
@@ -1073,7 +1059,7 @@ void SurfaceAggregator::CopyQuadsToPass(
         const auto* pass_quad = RenderPassDrawQuad::MaterialCast(quad);
         RenderPassId original_pass_id = pass_quad->render_pass_id;
         RenderPassId remapped_pass_id =
-            RemapPassId(original_pass_id, surface_id);
+            pass_id_remapper_.Remap(original_pass_id, surface_id);
 
         // If the RenderPassDrawQuad is referring to other render pass with the
         // |has_damage_from_contributing_content| set on it, then the dest_pass
@@ -1166,7 +1152,7 @@ void SurfaceAggregator::CopyPasses(const CompositorFrame& frame,
         (copy_pass->copy_requests.empty() || surface_transform.IsIdentity());
 
     RenderPassId remapped_pass_id =
-        RemapPassId(source.id, surface->surface_id());
+        pass_id_remapper_.Remap(source.id, surface->surface_id());
 
     gfx::Rect output_rect = source.output_rect;
     gfx::Rect damage_rect = source.output_rect;
@@ -1254,7 +1240,7 @@ gfx::Rect SurfaceAggregator::PrewalkRenderPass(
   }
 
   RenderPassId remapped_pass_id =
-      RemapPassId(render_pass.id, surface->surface_id());
+      pass_id_remapper_.Remap(render_pass.id, surface->surface_id());
   // |moved_pixel_passes_| stores all the render passes affected by filters
   // that move pixels, so |has_pixel_moving_filter| should be set to true either
   // if the current render pass has pixel_moving_filter(s) or if it is inside an
@@ -1389,7 +1375,7 @@ gfx::Rect SurfaceAggregator::PrewalkRenderPass(
       }
 
       RenderPassId remapped_child_pass_id =
-          RemapPassId(child_pass_id, surface->surface_id());
+          pass_id_remapper_.Remap(child_pass_id, surface->surface_id());
       if (in_moved_pixel_pass)
         moved_pixel_passes_.insert(remapped_child_pass_id);
 
@@ -1443,8 +1429,8 @@ gfx::Rect SurfaceAggregator::PrewalkSurface(Surface* surface,
     provider_->ReceiveFromChild(child_id, frame.resource_list);
   }
 
-  RenderPassId remapped_pass_id =
-      RemapPassId(frame.render_pass_list.back()->id, surface->surface_id());
+  RenderPassId remapped_pass_id = pass_id_remapper_.Remap(
+      frame.render_pass_list.back()->id, surface->surface_id());
   if (in_moved_pixel_surface)
     moved_pixel_passes_.insert(remapped_pass_id);
   if (parent_pass_id)
@@ -1549,7 +1535,7 @@ gfx::Rect SurfaceAggregator::PrewalkSurface(Surface* surface,
   for (const auto& render_pass : frame.render_pass_list) {
     if (!render_pass->copy_requests.empty()) {
       RenderPassId remapped_pass_id =
-          RemapPassId(render_pass->id, surface->surface_id());
+          pass_id_remapper_.Remap(render_pass->id, surface->surface_id());
       copy_request_passes_.insert(remapped_pass_id);
     }
     if (render_pass->cache_render_pass)
@@ -1738,17 +1724,7 @@ CompositorFrame SurfaceAggregator::Aggregate(
   copy_request_passes_.clear();
   contributing_content_damaged_passes_.clear();
   render_pass_dependencies_.clear();
-
-  // Remove all render pass mappings that weren't used in the current frame.
-  for (auto it = render_pass_allocator_map_.begin();
-       it != render_pass_allocator_map_.end();) {
-    if (it->second.in_use) {
-      it->second.in_use = false;
-      it++;
-    } else {
-      it = render_pass_allocator_map_.erase(it);
-    }
-  }
+  pass_id_remapper_.ClearUnusedMappings();
 
   DCHECK(referenced_surfaces_.empty());
 
@@ -1973,8 +1949,8 @@ void SurfaceAggregator::HandleDeJelly(Surface* surface) {
       skew_transform.Skew(0.0f, max_skew);
       // Ignore rectangles for now, these are updated in
       // CreateDeJellyRenderPassQuads.
-      sub_render_pass->SetNew(next_render_pass_id_++, gfx::Rect(), gfx::Rect(),
-                              skew_transform);
+      sub_render_pass->SetNew(pass_id_remapper_.NextAvailableId(), gfx::Rect(),
+                              gfx::Rect(), skew_transform);
       // If blend mode is not kSrcOver, we apply it in the render pass.
       if (state->blend_mode != SkBlendMode::kSrcOver) {
         sub_render_pass_opacity = state->opacity;

components/viz/service/display/surface_aggregator.h

@@ -21,6 +21,7 @@
 #include "components/viz/common/resources/transferable_resource.h"
 #include "components/viz/common/surfaces/surface_id.h"
 #include "components/viz/common/surfaces/surface_range.h"
+#include "components/viz/service/display/render_pass_id_remapper.h"
 #include "components/viz/service/viz_service_export.h"
 #include "ui/gfx/display_color_spaces.h"
 #include "ui/gfx/overlay_transform.h"
@@ -92,13 +93,6 @@ class VIZ_SERVICE_EXPORT SurfaceAggregator {
   struct ChildSurfaceInfo;
   struct RenderPassMapEntry;
 
-  struct RenderPassInfo {
-    // This is the id the pass is mapped to.
-    int id;
-    // This is true if the pass was used in the last aggregated frame.
-    bool in_use = true;
-  };
-
   // Helper function that gets a list of render passes and returns a map from
   // render pass ids to render passes.
   static base::flat_map<RenderPassId, RenderPassMapEntry> GenerateRenderPassMap(
@@ -109,9 +103,6 @@ class VIZ_SERVICE_EXPORT SurfaceAggregator {
                              const ClipData& quad_clip,
                              const gfx::Transform& target_transform);
 
-  RenderPassId RemapPassId(RenderPassId surface_local_pass_id,
-                           const SurfaceId& surface_id);
-
   void HandleSurfaceQuad(const SurfaceDrawQuad* surface_quad,
                          float parent_device_scale_factor,
                          const gfx::Transform& target_transform,
@@ -322,13 +313,6 @@ class VIZ_SERVICE_EXPORT SurfaceAggregator {
   SurfaceManager* manager_;
   DisplayResourceProvider* provider_;
 
-  // Every Surface has its own RenderPass ID namespace. This structure maps
-  // each source (SurfaceId, RenderPass id) to a unified ID namespace that's
-  // used in the aggregated frame. An entry is removed from the map if it's not
-  // used for one output frame.
-  base::flat_map<std::pair<SurfaceId, RenderPassId>, RenderPassInfo>
-      render_pass_allocator_map_;
-  RenderPassId next_render_pass_id_;
   const bool aggregate_only_damaged_;
   bool output_is_secure_;
 
@@ -451,6 +435,10 @@ class VIZ_SERVICE_EXPORT SurfaceAggregator {
   // after it is placed on the final aggregated frame during aggregation.
   std::unique_ptr<DelegatedInkMetadata> delegated_ink_metadata_;
 
+  // A helper class used to remap render pass IDs from the surface namespace to
+  // a common space, to avoid collisions.
+  RenderPassIdRemapper pass_id_remapper_;
+
   base::WeakPtrFactory<SurfaceAggregator> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceAggregator);