cc: Plumbing for BeginFrameSource based on Surfaces

cc/surfaces/surface_aggregator.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/surface_aggregator.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
@@ skipping 11 matching lines @@
   for (auto it = request_range.first; it != request_range.second; ++it) {
     DCHECK(it->second);
     output_requests->push_back(scoped_ptr<CopyOutputRequest>(it->second));
     it->second = nullptr;
   }
   copy_requests->erase(request_range.first, request_range.second);
 }
 
 }  // namespace
 
-SurfaceAggregator::SurfaceAggregator(SurfaceManager* manager,
+SurfaceAggregator::SurfaceAggregator(SurfaceAggregatorClient* client,
+                                     SurfaceManager* manager,
                                      ResourceProvider* provider,
                                      bool aggregate_only_damaged)
-    : manager_(manager),
+    : client_(client),
+      manager_(manager),
       provider_(provider),
       next_render_pass_id_(1),
       aggregate_only_damaged_(aggregate_only_damaged) {
   DCHECK(manager_);
 }
 
-SurfaceAggregator::~SurfaceAggregator() {}
+SurfaceAggregator::~SurfaceAggregator() {

[mithro-old, 2015/10/01 03:00:23]

I feel like this should be calling ProcessAddedAndRemovedSurfaces() after
resetting contained_surfaces to null? Would that work?

[brianderson, 2015/10/07 20:54:48]

+jbauman: wdyt? Doing that sounds like a good idea, but it would also release
resources of the previously_contained_surfaces. Is there already code elsewhere
that releases resources before we get to this destructor?

[jbauman, 2015/10/13 20:23:20]

I think that should work. I just checked and the destructor order happening with
the cc::Display makes sense.

+  // Notify client of all surfaces being removed.
+  for (const auto& surface : previous_contained_surfaces_) {
+    Surface* surface_ptr = manager_->GetSurfaceForId(surface.first);
+    if (surface_ptr)
+      client_->RemoveSurface(surface_ptr);
+  }
+}
 
 // Create a clip rect for an aggregated quad from the original clip rect and
 // the clip rect from the surface it's on.
 SurfaceAggregator::ClipData SurfaceAggregator::CalculateClipRect(
     const ClipData& surface_clip,
     const ClipData& quad_clip,
     const gfx::Transform& target_transform) {
   ClipData out_clip;
   if (surface_clip.is_clipped)
     out_clip = surface_clip;
@@ skipping 64 matching lines @@
       provider_->SetChildNeedsSyncPoints(
           child_id, surface->factory()->needs_sync_points());
     }
     surface_id_to_resource_child_id_[surface->surface_id()] = child_id;
     return child_id;
   } else {
     return it->second;
   }
 }
 
+gfx::Rect SurfaceAggregator::DamageRectForSurface(
+    const Surface* surface,
+    const RenderPass& source,
+    const gfx::Rect& full_rect) const {
+  auto it = previous_contained_surfaces_.find(surface->surface_id());
+  if (it == previous_contained_surfaces_.end())
+    return full_rect;
 
-gfx::Rect SurfaceAggregator::DamageRectForSurface(const Surface* surface,
-                                                  const RenderPass& source,
-                                                  const gfx::Rect& full_rect) {
-  int previous_index = previous_contained_surfaces_[surface->surface_id()];
+  int previous_index = it->second;
   if (previous_index == surface->frame_index())
     return gfx::Rect();
-  else if (previous_index == surface->frame_index() - 1)
+  if (previous_index == surface->frame_index() - 1)
     return source.damage_rect;
   return full_rect;
 }
 
 void SurfaceAggregator::HandleSurfaceQuad(
     const SurfaceDrawQuad* surface_quad,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_pass) {
   SurfaceId surface_id = surface_quad->surface_id;
@@ skipping 287 matching lines @@
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     child_to_parent_map, gfx::Transform(), ClipData(),
                     copy_pass.get(), surface->surface_id());
 
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 }
 
-void SurfaceAggregator::RemoveUnreferencedChildren() {
+void SurfaceAggregator::ProcessAddedAndRemovedSurfaces() {
   for (const auto& surface : previous_contained_surfaces_) {
     if (!contained_surfaces_.count(surface.first)) {
+      // Release resources of removed surface.
       SurfaceToResourceChildIdMap::iterator it =
           surface_id_to_resource_child_id_.find(surface.first);
       if (it != surface_id_to_resource_child_id_.end()) {
         provider_->DestroyChild(it->second);
         surface_id_to_resource_child_id_.erase(it);
       }
 
+      // Notify client of removed surface.
+      Surface* surface_ptr = manager_->GetSurfaceForId(surface.first);
+      if (surface_ptr) {
+        surface_ptr->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
+        client_->RemoveSurface(surface_ptr);
+      }
+    }
+  }
+
+  for (const auto& surface : contained_surfaces_) {
+    if (!previous_contained_surfaces_.count(surface.first)) {
+      // Notify client of added surface.
       Surface* surface_ptr = manager_->GetSurfaceForId(surface.first);
       if (surface_ptr)
-        surface_ptr->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
+        client_->AddSurface(surface_ptr);
     }
   }
 }
 
 // Walk the Surface tree from surface_id. Validate the resources of the current
 // surface and its descendants, check if there are any copy requests, and
 // return the combined damage rect.
 gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id) {
   if (referenced_surfaces_.count(surface_id))
     return gfx::Rect();
@@ skipping 119 matching lines @@
   CopyPasses(root_surface_frame->delegated_frame_data.get(), surface);
   referenced_surfaces_.erase(it);
 
   DCHECK(referenced_surfaces_.empty());
 
   if (dest_pass_list_->empty())
     return nullptr;
   dest_pass_list_->back()->damage_rect = root_damage_rect_;
 
   dest_pass_list_ = NULL;
-  RemoveUnreferencedChildren();
+  ProcessAddedAndRemovedSurfaces();
   contained_surfaces_.swap(previous_contained_surfaces_);
   contained_surfaces_.clear();
 
   for (SurfaceIndexMap::iterator it = previous_contained_surfaces_.begin();
        it != previous_contained_surfaces_.end();
        ++it) {
     Surface* surface = manager_->GetSurfaceForId(it->first);
     if (surface)
       surface->TakeLatencyInfo(&frame->metadata.latency_info);
   }
@@ skipping 15 matching lines @@
 
 void SurfaceAggregator::SetFullDamageForSurface(SurfaceId surface_id) {
   auto it = previous_contained_surfaces_.find(surface_id);
   if (it == previous_contained_surfaces_.end())
     return;
   // Set the last drawn index as 0 to ensure full damage next time it's drawn.
   it->second = 0;
 }
 
 }  // namespace cc