Add callback when queueing frame on Surface to create backpressure.

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/surface_factory.h"
 
 namespace cc {
@@ skipping 24 matching lines @@
         previous_frame->delegated_frame_data->resource_list,
         &previous_resources);
     factory_->UnrefResources(previous_resources);
   }
 }
 
 const CompositorFrame* Surface::GetEligibleFrame() {
   return current_frame_.get();
 }
 
+void Surface::AddDrawCallback(const base::Closure& closure) {

[jamesr, 2014/08/22 06:00:12]

nit: this is called 'callback' other places, which makes slightly more sense

+  draw_callbacks_.push_back(closure);
+}
+
+void Surface::RunDrawCallbacks() {
+  for (std::vector<base::Closure>::iterator it = draw_callbacks_.begin();
+       it != draw_callbacks_.end();
+       ++it) {
+    it->Run();

[jamesr, 2014/08/22 06:00:12]

if one of the callbacks manipulates our callback list or destroys us we'll be a
sad puppy. a slightly safer way to write this loop is:

typedef std::vector<base::Closure> CallbackList;

CallbackList to_run;
draw_callbacks_.swap(to_run);
for (CallbackList::iterator it = to_run.begin(); it != to_run.end(); ++it) {
  it->Run();
}

this also means that if a draw callback queues another callback the new one will
fire on the next draw, not this one, which is probably what they want if they're
queing frames as soon as they get an ACK

+  }
+  draw_callbacks_.clear();

[jamesr, 2014/08/22 06:00:12]

if a surface is referenced in multiple displays the callback will fire when the
first one draws, which is *probably* what we want to happen in most cases but
might be surprising. something to keep in mind...

+}
+
 }  // namespace cc