Prevent use of GPU IDC in Resourceless Software Draw

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1666 matching lines @@
   if (active_tree_->hud_layer()) {
     TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
     active_tree_->hud_layer()->UpdateHudTexture(draw_mode,
                                                 resource_provider_.get());
   }
 
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     bool disable_picture_quad_image_filtering =
         IsActivelyScrolling() || animation_host_->NeedsAnimateLayers();
 
+    // We must disable the image hijack canvas when using GPU rasterization but
+    // performing a resourceless software draw. Otherwise, we will attempt to
+    // use the GPU ImageDecodeController during software raster.
+    bool use_image_hijack_canvas = !use_gpu_rasterization_;
+
     std::unique_ptr<SoftwareRenderer> temp_software_renderer =
         SoftwareRenderer::Create(this, &settings_.renderer_settings,
-                                 output_surface_, NULL);
+                                 output_surface_, NULL,

[vmpstr, 2016/06/02 19:57:47]

nit: nullptr while here.

[ericrk, 2016/06/02 20:45:36]

Done.

+                                 use_image_hijack_canvas);
     temp_software_renderer->DrawFrame(
         &frame->render_passes, active_tree_->device_scale_factor(),
         DeviceViewport(), DeviceClip(), disable_picture_quad_image_filtering);
   } else {
     renderer_->DrawFrame(&frame->render_passes,
                          active_tree_->device_scale_factor(), DeviceViewport(),
                          DeviceClip(), false);
   }
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
@@ skipping 448 matching lines @@
   if (output_surface_->capabilities().delegated_rendering) {
     renderer_ =
         DelegatingRenderer::Create(this, &settings_.renderer_settings,
                                    output_surface_, resource_provider_.get());
   } else if (output_surface_->context_provider()) {
     renderer_ = GLRenderer::Create(
         this, &settings_.renderer_settings, output_surface_,
         resource_provider_.get(), texture_mailbox_deleter_.get(),
         settings_.renderer_settings.highp_threshold_min);
   } else if (output_surface_->software_device()) {
-    renderer_ =
-        SoftwareRenderer::Create(this, &settings_.renderer_settings,
-                                 output_surface_, resource_provider_.get());
+    renderer_ = SoftwareRenderer::Create(
+        this, &settings_.renderer_settings, output_surface_,
+        resource_provider_.get(), true /* use_image_hijack_canvas */);
   }
   DCHECK(renderer_);
 
   renderer_->SetVisible(visible_);
   SetFullRootLayerDamage();
 
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
   // initialized to get max texture size.  Also, after releasing resources,
   // trees need another update to generate new ones.
   active_tree_->set_needs_update_draw_properties();
@@ skipping 1876 matching lines @@
     const {
   return fixed_raster_scale_attempted_scale_change_history_.count() >=
          kFixedRasterScaleAttemptedScaleChangeThreshold;
 }
 
 void LayerTreeHostImpl::SetFixedRasterScaleAttemptedToChangeScale() {
   fixed_raster_scale_attempted_scale_change_history_.set(0);
 }
 
 }  // namespace cc