Update from https://crrev.com/308331

cc/surfaces/display.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/display.h"
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 100 matching lines @@
 
   // TODO(skyostil): We should hold a BlockingTaskRunner::CapturePostTasks
   // while Aggregate is called to immediately run release callbacks afterward.
   scoped_ptr<CompositorFrame> frame =
       aggregator_->Aggregate(current_surface_id_);
   if (!frame)
     return false;
 
   TRACE_EVENT0("cc", "Display::Draw");
   benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
+
+  // Run callbacks early to allow pipelining.
+  for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
+    Surface* surface = manager_->GetSurfaceForId(id_entry.first);
+    if (surface)
+      surface->RunDrawCallbacks();
+  }
   DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
 
   gfx::Size surface_size =
       frame_data->render_pass_list.back()->output_rect.size();
 
   gfx::Rect device_viewport_rect = gfx::Rect(current_surface_size_);
   gfx::Rect device_clip_rect = device_viewport_rect;
   bool disable_picture_quad_image_filtering = false;
 
   renderer_->DecideRenderPassAllocationsForFrame(frame_data->render_pass_list);
   renderer_->DrawFrame(&frame_data->render_pass_list,
                        device_scale_factor_,
                        device_viewport_rect,
                        device_clip_rect,
                        disable_picture_quad_image_filtering);
 
-  bool disable_swap = surface_size != current_surface_size_;
-  if (disable_swap) {
+  if (surface_size != current_surface_size_) {
     DidSwapBuffers();
+    DidSwapBuffersComplete();
   } else {
     renderer_->SwapBuffers(frame->metadata);
   }
 
-  for (SurfaceAggregator::SurfaceIndexMap::iterator it =
-           aggregator_->previous_contained_surfaces().begin();
-       it != aggregator_->previous_contained_surfaces().end();
-       ++it) {
-    Surface* surface = manager_->GetSurfaceForId(it->first);
-    if (surface)
-      surface->RunDrawCallbacks();
-  }
-  if (disable_swap)
-    DidSwapBuffersComplete();
   return true;
 }
 
 void Display::DidSwapBuffers() {
   client_->DidSwapBuffers();
 }
 
 void Display::DidSwapBuffersComplete() {
   client_->DidSwapBuffersComplete();
 }
 
 void Display::CommitVSyncParameters(base::TimeTicks timebase,
                                     base::TimeDelta interval) {
   client_->CommitVSyncParameters(timebase, interval);
 }
 
 void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   client_->SetMemoryPolicy(policy);
 }
 
 void Display::OnSurfaceDamaged(SurfaceId surface) {
-  if (aggregator_ && aggregator_->previous_contained_surfaces().count(surface))
+  if (aggregator_ &&
+      aggregator_->previous_contained_surfaces().count(surface)) {
+    aggregator_->ReleaseResources(surface);
     client_->DisplayDamaged();
+  }
 }
 
 SurfaceId Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 int Display::GetMaxFramesPending() {
   if (!output_surface_)
     return OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
   return output_surface_->capabilities().max_frames_pending;
 }
 
 }  // namespace cc