Enqueuing new frames in a Surface should cause Displays to reaggregate it

cc/surfaces/surface.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.h"
 
 #include "cc/output/compositor_frame.h"
+#include "cc/surfaces/display.h"
 #include "cc/surfaces/surface_factory.h"
 
 namespace cc {
 
 Surface::Surface(SurfaceId id, const gfx::Size& size, SurfaceFactory* factory)
     : surface_id_(id), size_(size), factory_(factory) {
 }
 
 Surface::~Surface() {
+  for (std::set<Display*>::iterator it = containing_displays_.begin();

[jamesr, 2014/08/07 21:04:06]

if you used IDs then you wouldn't need to do this - the SurfaceManager's
id->surface mapping is your weak pointer

+       it != containing_displays_.end();
+       ++it) {
+    (*it)->contained_surfaces().erase(this);
+  }
   if (current_frame_) {
     ReturnedResourceArray current_resources;
     TransferableResource::ReturnResources(
         current_frame_->delegated_frame_data->resource_list,
         &current_resources);
     factory_->UnrefResources(current_resources);
   }
 }
 
 void Surface::QueueFrame(scoped_ptr<CompositorFrame> frame) {
   scoped_ptr<CompositorFrame> previous_frame = current_frame_.Pass();
   current_frame_ = frame.Pass();
   factory_->ReceiveFromChild(
       current_frame_->delegated_frame_data->resource_list);
 
   if (previous_frame) {
     ReturnedResourceArray previous_resources;
     TransferableResource::ReturnResources(
         previous_frame->delegated_frame_data->resource_list,
         &previous_resources);
     factory_->UnrefResources(previous_resources);
   }
+  for (std::set<Display*>::iterator it = containing_displays_.begin();
+       it != containing_displays_.end();
+       ++it) {
+    (*it)->Draw();

[jamesr, 2014/08/07 21:04:06]

i think the service should be keeping track of this, not the individual
surfaces. i.e. the thing that's routing queue frame calls to Surface instances
can say 'ok, for this surface ID is there any display that needs to re-aggregate
as a result of this'?

also saying that a new frame needs a draw isn't entirely correct.  When
receiving a new frame, we need to re-aggregate and then look at the damage to
see if that requires us to draw or not. in many cases we won't actually have to
draw anything new

+  }
 }
 
 const CompositorFrame* Surface::GetEligibleFrame() {
   return current_frame_.get();
 }
 
 }  // namespace cc