cc: Async readback.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 559 matching lines @@
   typedef LayerIterator<LayerImpl,
                         LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
 
   // Typically when we are missing a texture and use a checkerboard quad, we
   // still draw the frame. However when the layer being checkerboarded is moving
   // due to an impl-animation, we drop the frame to avoid flashing due to the
   // texture suddenly appearing in the future.
   bool draw_frame = true;
+  // When we have a copy request for a layer, we need to draw no matter
+  // what, as the layer may disappear after this frame.
+  bool have_copy_request = false;
 
   int layers_drawn = 0;
 
   LayerIteratorType end =
       LayerIteratorType::End(frame->render_surface_layer_list);
   for (LayerIteratorType it =
            LayerIteratorType::Begin(frame->render_surface_layer_list);
        it != end;
        ++it) {
     RenderPass::Id target_render_pass_id =
         it.target_render_surface_layer()->render_surface()->RenderPassId();
     RenderPass* target_render_pass =
         frame->render_passes_by_id[target_render_pass_id];
 
     occlusion_tracker.EnterLayer(it);
 
     AppendQuadsData append_quads_data(target_render_pass->id);
 
-    if (it.represents_contributing_render_surface()) {
+    if (it.represents_target_render_surface()) {
+      if (it->HasRequestCopyCallback()) {
+        have_copy_request = true;
+        it->TakeRequestCopyCallbacks(&target_render_pass->copy_callbacks);
+      }
+    } else if (it.represents_contributing_render_surface()) {
       RenderPass::Id contributing_render_pass_id =
           it->render_surface()->RenderPassId();
       RenderPass* contributing_render_pass =
           frame->render_passes_by_id[contributing_render_pass_id];
       AppendQuadsForRenderSurfaceLayer(target_render_pass,
                                        *it,
                                        contributing_render_pass,
                                        occlusion_tracker,
                                        &append_quads_data);
     } else if (it.represents_itself() &&
@@ skipping 55 matching lines @@
       if (layer_has_animating_transform)
         draw_frame = false;
     }
 
     if (append_quads_data.had_incomplete_tile)
       frame->contains_incomplete_tile = true;
 
     occlusion_tracker.LeaveLayer(it);
   }
 
+  if (have_copy_request)
+    draw_frame = true;
+
   rendering_stats_instrumentation_->AddLayersDrawn(layers_drawn);
 
 #ifndef NDEBUG
   for (size_t i = 0; i < frame->render_passes.size(); ++i) {
     for (size_t j = 0; j < frame->render_passes[i]->quad_list.size(); ++j)
       DCHECK(frame->render_passes[i]->quad_list[j]->shared_quad_state);
     DCHECK(frame->render_passes_by_id.find(frame->render_passes[i]->id)
            != frame->render_passes_by_id.end());
   }
 #endif
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 
   if (!active_tree_->has_transparent_background()) {
     frame->render_passes.back()->has_transparent_background = false;
     AppendQuadsToFillScreen(frame->render_passes.back(),
                             active_tree_->root_layer(),
                             active_tree_->background_color(),
                             occlusion_tracker);
   }
 
   if (draw_frame)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
+  else
+    DCHECK(!have_copy_request);
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
   RemoveRenderPasses(CullRenderPassesWithCachedTextures(renderer_.get()),
                      frame);
 
   // If we're making a frame to draw, it better have at least one render pass.
   DCHECK(!frame->render_passes.empty());
   return draw_frame;
 }
@@ skipping 1409 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc