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

cc/surfaces/display.cc

 // Copyright 2014 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/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 34 matching lines @@
       bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       settings_(settings),
       compositor_surface_namespace_(compositor_surface_namespace),
       begin_frame_source_(std::move(begin_frame_source)),
       output_surface_(std::move(output_surface)),
       scheduler_(std::move(scheduler)),
       texture_mailbox_deleter_(std::move(texture_mailbox_deleter)) {
   DCHECK(surface_manager_);
   DCHECK(output_surface_);
-  DCHECK(texture_mailbox_deleter_);
   DCHECK_EQ(!scheduler_, !begin_frame_source_);
 
   surface_manager_->AddObserver(this);
 
   if (scheduler_)
     scheduler_->SetClient(this);
 }
 
 Display::~Display() {
   // Only do this if Initialize() happened.
@@ skipping 90 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider(new ResourceProvider(
       output_surface_->context_provider(), bitmap_manager_,
       gpu_memory_buffer_manager_, nullptr, settings_.highp_threshold_min,
       settings_.texture_id_allocation_chunk_size,
       output_surface_->capabilities().delegated_sync_points_required,
       settings_.use_gpu_memory_buffer_resources,
       std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
                             GL_TEXTURE_2D)));
 
   if (output_surface_->context_provider()) {
+    DCHECK(texture_mailbox_deleter_);
     std::unique_ptr<GLRenderer> renderer = GLRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
   } else if (output_surface_->vulkan_context_provider()) {
 #if defined(ENABLE_VULKAN)
+    DCHECK(texture_mailbox_deleter_);
     std::unique_ptr<VulkanRenderer> renderer = VulkanRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
 #else
     NOTREACHED();
 #endif
   } else {
     std::unique_ptr<SoftwareRenderer> renderer = SoftwareRenderer::Create(
-        this, &settings_, output_surface_.get(), resource_provider.get(),
-        true /* use_image_hijack_canvas */);
+        this, &settings_, output_surface_.get(), resource_provider.get());
     if (!renderer)
       return;
+    software_renderer_ = renderer.get();
     renderer_ = std::move(renderer);
   }
 
   renderer_->SetEnlargePassTextureAmount(enlarge_texture_amount_);
 
   resource_provider_ = std::move(resource_provider);
   // TODO(jbauman): Outputting an incomplete quad list doesn't work when using
   // overlays.
   bool output_partial_list = renderer_->Capabilities().using_partial_swap &&
                              !output_surface_->GetOverlayCandidateValidator();
@@ skipping 84 matching lines @@
   if (output_surface_->SurfaceIsSuspendForRecycle()) {
     TRACE_EVENT_INSTANT0("cc", "Surface is suspended for recycle.",
                          TRACE_EVENT_SCOPE_THREAD);
     should_draw = false;
   }
 
   if (should_draw) {
     gfx::Rect device_viewport_rect = gfx::Rect(current_surface_size_);
     gfx::Rect device_clip_rect =
         external_clip_.IsEmpty() ? device_viewport_rect : external_clip_;
-    bool disable_picture_quad_image_filtering = false;
+
+    bool disable_image_filtering =
+        frame.metadata.is_resourceless_software_draw_with_scroll_or_animation;
+    if (software_renderer_) {
+      software_renderer_->SetDisablePictureQuadImageFiltering(
+          disable_image_filtering);
+    } else {
+      // This should only be set for software draws in synchronous compositor.
+      DCHECK(!disable_image_filtering);
+    }
 
     renderer_->DecideRenderPassAllocationsForFrame(
         frame_data->render_pass_list);
     renderer_->DrawFrame(&frame_data->render_pass_list, device_scale_factor_,
                          device_color_space_, device_viewport_rect,
-                         device_clip_rect,
-                         disable_picture_quad_image_filtering);
+                         device_clip_rect);
   } else {
     TRACE_EVENT_INSTANT0("cc", "Draw skipped.", TRACE_EVENT_SCOPE_THREAD);
   }
 
   bool should_swap = should_draw && size_matches;
   if (should_swap) {
     swapped_since_resize_ = true;
     for (auto& latency : frame.metadata.latency_info) {
       TRACE_EVENT_WITH_FLOW1("input,benchmark", "LatencyInfo.Flow",
           TRACE_ID_DONT_MANGLE(latency.trace_id()),
@@ skipping 104 matching lines @@
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
 SurfaceId Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 }  // namespace cc