cc: Make PrepareToDraw return an enum for why it aborts

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 <limits>
 
 #include "base/basictypes.h"
@@ skipping 679 matching lines @@
                         overhang_resource_scaled_size.width(),
                     layer_rect.bottom() /
                         overhang_resource_scaled_size.height()),
         screen_background_color,
         vertex_opacity,
         false);
       quad_culler.Append(tex_quad.PassAs<DrawQuad>(), &append_quads_data);
   }
 }
 
-bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
+DrawSwapReadbackResult::DrawResult LayerTreeHostImpl::CalculateRenderPasses(
+    FrameData* frame) {
   DCHECK(frame->render_passes.empty());
 
-  if (!CanDraw() || !active_tree_->root_layer())
-    return false;
+  if (!CanDraw())
+    return DrawSwapReadbackResult::DRAW_ABORTED_CANT_DRAW;
+  if (!active_tree_->root_layer())
+    return DrawSwapReadbackResult::DRAW_ABORTED_NO_TREE;
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
 
   // If the root render surface has no visible damage, then don't generate a
   // frame at all.
   RenderSurfaceImpl* root_surface =
       active_tree_->root_layer()->render_surface();
   bool root_surface_has_no_visible_damage =
       !root_surface->damage_tracker()->current_damage_rect().Intersects(
           root_surface->content_rect());
   bool root_surface_has_contributing_layers =
       !root_surface->layer_list().empty();
   if (root_surface_has_contributing_layers &&
       root_surface_has_no_visible_damage) {
     TRACE_EVENT0("cc",
                  "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
     frame->has_no_damage = true;
     // A copy request should cause damage, so we should not have any copy
     // requests in this case.
     DCHECK_EQ(0u, active_tree_->LayersWithCopyOutputRequest().size());
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
-    return true;
+    return DrawSwapReadbackResult::DID_DRAW;
   }
 
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::CalculateRenderPasses",
                "render_surface_layer_list.size()",
                static_cast<uint64>(frame->render_surface_layer_list->size()));
 
   // Create the render passes in dependency order.
   for (int surface_index = frame->render_surface_layer_list->size() - 1;
        surface_index >= 0;
@@ skipping 33 matching lines @@
   // occlusion and performing culling during the tree walk.
   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;
+  DrawSwapReadbackResult::DrawResult draw_result =
+      DrawSwapReadbackResult::DID_DRAW;
   // 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;
 
   const DrawMode draw_mode = GetDrawMode(output_surface_.get());
 
   LayerIteratorType end =
       LayerIteratorType::End(frame->render_surface_layer_list);
@@ skipping 65 matching lines @@
                             &append_quads_data);
       }
 
       ++layers_drawn;
     }
 
     if (append_quads_data.num_missing_tiles) {
       bool layer_has_animating_transform =
           it->screen_space_transform_is_animating() ||
           it->draw_transform_is_animating();
-      if (layer_has_animating_transform)
-        draw_frame = false;
+      if (layer_has_animating_transform) {
+        draw_result =
+            DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
+      }
     }
 
     if (append_quads_data.had_incomplete_tile)
       frame->contains_incomplete_tile = true;
 
     occlusion_tracker.LeaveLayer(it);
   }
 
   if (have_copy_request ||
       output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
-    draw_frame = true;
+    draw_result = DrawSwapReadbackResult::DID_DRAW;
 
 #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(
         ResourceIdForUIResource(overhang_ui_resource_id_),
         gfx::ScaleSize(overhang_ui_resource_size_, device_scale_factor_),
         active_tree_->RootScrollLayerDeviceViewportBounds(),
         frame->render_passes.back(),
         active_tree_->root_layer(),
         active_tree_->background_color(),
         occlusion_tracker);
   }
 
-  if (draw_frame)
+  if (draw_result == DrawSwapReadbackResult::DID_DRAW)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
   else
     DCHECK(!have_copy_request);
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
 
   // Any copy requests left in the tree are not going to get serviced, and
   // should be aborted.
   ScopedPtrVector<CopyOutputRequest> requests_to_abort;
   while (!active_tree_->LayersWithCopyOutputRequest().empty()) {
     LayerImpl* layer = active_tree_->LayersWithCopyOutputRequest().back();
     layer->TakeCopyRequestsAndTransformToTarget(&requests_to_abort);
   }
   for (size_t i = 0; i < requests_to_abort.size(); ++i)
     requests_to_abort[i]->SendEmptyResult();
 
   // If we're making a frame to draw, it better have at least one render pass.
   DCHECK(!frame->render_passes.empty());
 
   // Should only have one render pass in resourceless software mode.
   if (output_surface_->ForcedDrawToSoftwareDevice())
     DCHECK_EQ(1u, frame->render_passes.size());
 
-  return draw_frame;
+  return draw_result;
 }
 
 void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
   if (input_handler_client_)
     input_handler_client_->MainThreadHasStoppedFlinging();
 }
 
 void LayerTreeHostImpl::UpdateBackgroundAnimateTicking(
     bool should_background_tick) {
   DCHECK(proxy_->IsImplThread());
@@ skipping 131 matching lines @@
       // change. So, capture the iterator position from the end of the
       // list, and restore it after the change.
       size_t position_from_end = frame->render_passes.size() - it;
       RemoveRenderPassesRecursive(render_pass_quad->render_pass_id, frame);
       it = frame->render_passes.size() - position_from_end;
       DCHECK_GE(frame->render_passes.size(), position_from_end);
     }
   }
 }
 
-bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame,
-                                      const gfx::Rect& damage_rect) {
+DrawSwapReadbackResult::DrawResult LayerTreeHostImpl::PrepareToDraw(
+    FrameData* frame,
+    const gfx::Rect& damage_rect) {
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::PrepareToDraw",
                "SourceFrameNumber",
                active_tree_->source_frame_number());
 
   if (need_to_update_visible_tiles_before_draw_ &&
       tile_manager_ && tile_manager_->UpdateVisibleTiles()) {
     DidInitializeVisibleTile();
   }
   need_to_update_visible_tiles_before_draw_ = true;
 
   active_tree_->UpdateDrawProperties();
 
   frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
   frame->render_passes.clear();
   frame->render_passes_by_id.clear();
   frame->will_draw_layers.clear();
   frame->contains_incomplete_tile = false;
   frame->has_no_damage = false;
 
   gfx::Rect device_viewport_damage_rect(damage_rect);
   if (active_tree_->root_layer()) {
     device_viewport_damage_rect.Union(viewport_damage_rect_);
     viewport_damage_rect_ = gfx::Rect();
 
     active_tree_->root_layer()->render_surface()->damage_tracker()->
         AddDamageNextUpdate(device_viewport_damage_rect);
   }
 
-  if (!CalculateRenderPasses(frame)) {
+  DrawSwapReadbackResult::DrawResult draw_result = CalculateRenderPasses(frame);
+  if (draw_result != DrawSwapReadbackResult::DID_DRAW) {
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
-    return false;
+    return draw_result;
   }
 
-  // If we return true, then we expect DrawLayers() to be called before this
+  // If we return DID_DRAW, then we expect DrawLayers() to be called before this
   // function is called again.
-  return true;
+  return draw_result;
 }
 
 void LayerTreeHostImpl::EvictTexturesForTesting() {
   EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
 }
 
 void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
   NOTREACHED();
 }
 
@@ skipping 1791 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc