Use a cc::Display for WebView resourceless software draws.

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 1577 matching lines @@
 
   active_tree_->GetViewportSelection(&metadata.selection);
 
   if (OuterViewportScrollLayer()) {
     metadata.root_overflow_x_hidden =
         !OuterViewportScrollLayer()->user_scrollable_horizontal();
     metadata.root_overflow_y_hidden =
         !OuterViewportScrollLayer()->user_scrollable_vertical();
   }
 
+  if (GetDrawMode() == DRAW_MODE_RESOURCELESS_SOFTWARE) {
+    metadata.is_resourceless_software_draw_with_scroll_or_animation =
+        IsActivelyScrolling() || animation_host_->NeedsAnimateLayers();
+  }
+
   for (LayerImpl* surface_layer : active_tree_->SurfaceLayers()) {
     metadata.referenced_surfaces.push_back(
         static_cast<SurfaceLayerImpl*>(surface_layer)->surface_id());
   }
   if (!InnerViewportScrollLayer())
     return metadata;
 
   metadata.root_overflow_x_hidden |=
       !InnerViewportScrollLayer()->user_scrollable_horizontal();
   metadata.root_overflow_y_hidden |=
@@ skipping 54 matching lines @@
 
   // Because the contents of the HUD depend on everything else in the frame, the
   // contents of its texture are updated as the last thing before the frame is
   // drawn.
   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_, nullptr,
-                                 use_image_hijack_canvas);
-    temp_software_renderer->DrawFrame(
-        &frame->render_passes, active_tree_->device_scale_factor(),
-        gfx::ColorSpace(), DeviceViewport(), DeviceClip(),
-        disable_picture_quad_image_filtering);
-  } else {
-    renderer_->DrawFrame(&frame->render_passes,
-                         active_tree_->device_scale_factor(), gfx::ColorSpace(),
-                         DeviceViewport(), DeviceClip(), false);
-  }
+  renderer_->DrawFrame(&frame->render_passes,
+                       active_tree_->device_scale_factor(), gfx::ColorSpace(),
+                       DeviceViewport(), DeviceClip());
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
 
   // The next frame should start by assuming nothing has changed, and changes
   // are noted as they occur.
   // TODO(boliu): If we did a temporary software renderer frame, propogate the
   // damage forward to the next frame.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
         DidDrawDamagedArea();
@@ skipping 436 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(), true /* use_image_hijack_canvas */);
+    renderer_ =
+        SoftwareRenderer::Create(this, &settings_.renderer_settings,
+                                 output_surface_, resource_provider_.get());
   }
   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 1873 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc