Skip drawing unsupported layers in forced software mode

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/json/json_writer.h"
@@ skipping 396 matching lines @@
         render_surface_layer->filter().get());
   }
 }
 
 void LayerTreeHostImpl::FrameData::AppendRenderPass(
     scoped_ptr<RenderPass> render_pass) {
   render_passes_by_id[render_pass->id] = render_pass.get();
   render_passes.push_back(render_pass.Pass());
 }
 
+static DrawMode GetDrawMode(OutputSurface* output_surface) {
+  if (output_surface->software_device() && !output_surface->context3d()) {
+    if (output_surface->ForcedDrawToSoftwareDevice()) {
+      return DRAW_MODE_RESOURCELESS_SOFTWARE;
+    } else {
+      return DRAW_MODE_SOFTWARE;
+    }
+  } else {
+    return DRAW_MODE_HARDWARE;
+  }
+}
+
 static void AppendQuadsForLayer(RenderPass* target_render_pass,
                                 LayerImpl* layer,
                                 const OcclusionTrackerImpl& occlusion_tracker,
                                 AppendQuadsData* append_quads_data) {
   bool for_surface = false;
   QuadCuller quad_culler(&target_render_pass->quad_list,
                          &target_render_pass->shared_quad_state_list,
                          layer,
                          occlusion_tracker,
                          layer->ShowDebugBorders(),
@@ skipping 158 matching lines @@
   // 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;
 
+  const DrawMode draw_mode = GetDrawMode(output_surface_.get());
+
   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];
 
+    AppendQuadsData append_quads_data(target_render_pass->id);
+
     bool prevent_occlusion = it.target_render_surface_layer()->HasCopyRequest();
     occlusion_tracker.EnterLayer(it, prevent_occlusion);
 
-    AppendQuadsData append_quads_data(target_render_pass->id);
-    if (output_surface_->ForcedDrawToSoftwareDevice())
-      append_quads_data.allow_tile_draw_quads = false;
-
     if (it.represents_target_render_surface()) {
       if (it->HasCopyRequest()) {
         have_copy_request = true;
         it->TakeCopyRequests(&target_render_pass->copy_requests);
       }
     } 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() &&
                !it->visible_content_rect().IsEmpty()) {
       bool has_occlusion_from_outside_target_surface;
       bool impl_draw_transform_is_unknown = false;
       if (occlusion_tracker.Occluded(
               it->render_target(),
               it->visible_content_rect(),
               it->draw_transform(),
               impl_draw_transform_is_unknown,
               it->is_clipped(),
               it->clip_rect(),
               &has_occlusion_from_outside_target_surface)) {
         append_quads_data.had_occlusion_from_outside_target_surface |=
             has_occlusion_from_outside_target_surface;
-      } else {
+      } else if (it->WillDraw(draw_mode, resource_provider_.get())) {
         DCHECK_EQ(active_tree_, it->layer_tree_impl());
-        it->WillDraw(resource_provider_.get());
+
         frame->will_draw_layers.push_back(*it);
 
         if (it->HasContributingDelegatedRenderPasses()) {
           RenderPass::Id contributing_render_pass_id =
               it->FirstContributingRenderPassId();
           while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
                  frame->render_passes_by_id.end()) {
             RenderPass* render_pass =
                 frame->render_passes_by_id[contributing_render_pass_id];
 
@@ skipping 1587 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