cc: Partial tile raster for BitmapTileTaskWorkerPool.

For software compositing, this will reuse resources when possible
to avoid rastering the full tile. This improves the time to
raster a single animating tab loading spinner from 0.283474 ms to
0.0729661 ms per frame, for a 74% reduction in raster time.

To reproduce use the --disable-gpu command line flag.

R=reveman, vmpstr
BUG=487387
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1157103006

Cr-Commit-Position: refs/heads/master@{#332257}

16 files changed, 95 insertions, 43 deletions

diff --git a/cc/raster/bitmap_tile_task_worker_pool.cc b/cc/raster/bitmap_tile_task_worker_pool.cc
index e27d329..fb6b277 100644
--- a/cc/raster/bitmap_tile_task_worker_pool.cc
+++ b/cc/raster/bitmap_tile_task_worker_pool.cc
@@ -20,23 +20,34 @@ namespace {
 class RasterBufferImpl : public RasterBuffer {
  public:
   RasterBufferImpl(ResourceProvider* resource_provider,
-                   const Resource* resource)
-      : lock_(resource_provider, resource->id()), resource_(resource) {}
+                   const Resource* resource,
+                   bool resource_has_previous_content)
+      : lock_(resource_provider, resource->id()),
+        resource_(resource),
+        resource_has_previous_content_(resource_has_previous_content) {}
 
   // Overridden from RasterBuffer:
   void Playback(const RasterSource* raster_source,
                 const gfx::Rect& raster_full_rect,
                 const gfx::Rect& raster_dirty_rect,
+                uint64_t new_content_id,
                 float scale) override {
-    // TODO(danakj): Implement partial raster using raster_dirty_rect.
+    gfx::Rect playback_rect = raster_full_rect;
+    if (resource_has_previous_content_) {
+      playback_rect.Intersect(raster_dirty_rect);
+    }
+    DCHECK(!playback_rect.IsEmpty())
+        << "Why are we rastering a tile that's not dirty?";
+
     TileTaskWorkerPool::PlaybackToMemory(
         lock_.sk_bitmap().getPixels(), resource_->format(), resource_->size(),
-        0, raster_source, raster_full_rect, raster_full_rect, scale);
+        0, raster_source, raster_full_rect, playback_rect, scale);
   }
 
  private:
   ResourceProvider::ScopedWriteLockSoftware lock_;
   const Resource* resource_;
+  bool resource_has_previous_content_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
 };
@@ -169,10 +180,12 @@ ResourceFormat BitmapTileTaskWorkerPool::GetResourceFormat() {
 
 scoped_ptr<RasterBuffer> BitmapTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource,
-    uint64_t new_content_id,
+    uint64_t resource_content_id,
     uint64_t previous_content_id) {
-  return make_scoped_ptr<RasterBuffer>(
-      new RasterBufferImpl(resource_provider_, resource));
+  bool resource_has_previous_content =
+      resource_content_id && resource_content_id == previous_content_id;
+  return make_scoped_ptr<RasterBuffer>(new RasterBufferImpl(
+      resource_provider_, resource, resource_has_previous_content));
 }
 
 void BitmapTileTaskWorkerPool::ReleaseBufferForRaster(
diff --git a/cc/raster/bitmap_tile_task_worker_pool.h b/cc/raster/bitmap_tile_task_worker_pool.h
index 2b95ccb..21b8cf5 100644
--- a/cc/raster/bitmap_tile_task_worker_pool.h
+++ b/cc/raster/bitmap_tile_task_worker_pool.h
@@ -43,7 +43,7 @@ class CC_EXPORT BitmapTileTaskWorkerPool : public TileTaskWorkerPool,
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
-      uint64_t new_content_id,
+      uint64_t resource_content_id,
       uint64_t previous_content_id) override;
   void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
diff --git a/cc/raster/gpu_tile_task_worker_pool.cc b/cc/raster/gpu_tile_task_worker_pool.cc
index b23347e..349bc1f 100644
--- a/cc/raster/gpu_tile_task_worker_pool.cc
+++ b/cc/raster/gpu_tile_task_worker_pool.cc
@@ -32,6 +32,7 @@ class RasterBufferImpl : public RasterBuffer {
   void Playback(const RasterSource* raster_source,
                 const gfx::Rect& raster_full_rect,
                 const gfx::Rect& raster_dirty_rect,
+                uint64_t new_content_id,
                 float scale) override {
     TRACE_EVENT0("cc", "RasterBufferImpl::Playback");
     ContextProvider* context_provider = rasterizer_->resource_provider()
@@ -211,7 +212,7 @@ void GpuTileTaskWorkerPool::CompleteTasks(const Task::Vector& tasks) {
 
 scoped_ptr<RasterBuffer> GpuTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource,
-    uint64_t new_content_id,
+    uint64_t resource_content_id,
     uint64_t previous_content_id) {
   return make_scoped_ptr<RasterBuffer>(
       new RasterBufferImpl(rasterizer_.get(), resource));
diff --git a/cc/raster/gpu_tile_task_worker_pool.h b/cc/raster/gpu_tile_task_worker_pool.h
index 41c159e..54c8620 100644
--- a/cc/raster/gpu_tile_task_worker_pool.h
+++ b/cc/raster/gpu_tile_task_worker_pool.h
@@ -41,7 +41,7 @@ class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
-      uint64_t new_content_id,
+      uint64_t resource_content_id,
       uint64_t previous_content_id) override;
   void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
diff --git a/cc/raster/one_copy_tile_task_worker_pool.cc b/cc/raster/one_copy_tile_task_worker_pool.cc
index 3d9439e..73ca692 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.cc
+++ b/cc/raster/one_copy_tile_task_worker_pool.cc
@@ -28,20 +28,18 @@ class RasterBufferImpl : public RasterBuffer {
                    ResourcePool* resource_pool,
                    ResourceFormat resource_format,
                    const Resource* output_resource,
-                   uint64_t new_content_id,
                    uint64_t previous_content_id)
       : worker_pool_(worker_pool),
         resource_provider_(resource_provider),
         resource_pool_(resource_pool),
         output_resource_(output_resource),
-        new_content_id_(new_content_id),
-        previous_content_id_(previous_content_id),
-        reusing_raster_resource_(true),
+        raster_content_id_(0),
         sequence_(0) {
     if (worker_pool->have_persistent_gpu_memory_buffers() &&
         previous_content_id) {
       raster_resource_ =
           resource_pool->TryAcquireResourceWithContentId(previous_content_id);
+      raster_content_id_ = previous_content_id;
     }
     if (raster_resource_) {
       DCHECK_EQ(resource_format, raster_resource_->format());
@@ -50,7 +48,6 @@ class RasterBufferImpl : public RasterBuffer {
     } else {
       raster_resource_ = resource_pool->AcquireResource(output_resource->size(),
                                                         resource_format);
-      reusing_raster_resource_ = false;
     }
 
     lock_.reset(new ResourceProvider::ScopedWriteLockGpuMemoryBuffer(
@@ -63,25 +60,30 @@ class RasterBufferImpl : public RasterBuffer {
 
     // Make sure any scheduled copy operations are issued before we release the
     // raster resource.
-    bool did_playback = sequence_ != 0;
-    if (did_playback)
+    if (sequence_)
       worker_pool_->AdvanceLastIssuedCopyTo(sequence_);
 
     // Return resources to pool so they can be used by another RasterBuffer
     // instance.
-    uint64_t id(did_playback ? new_content_id_ : previous_content_id_);
-    resource_pool_->ReleaseResource(raster_resource_.Pass(), id);
+    resource_pool_->ReleaseResource(raster_resource_.Pass(),
+                                    raster_content_id_);
   }
 
   // Overridden from RasterBuffer:
   void Playback(const RasterSource* raster_source,
                 const gfx::Rect& raster_full_rect,
                 const gfx::Rect& raster_dirty_rect,
+                uint64_t new_content_id,
                 float scale) override {
+    // If there's a raster_content_id_, we are reusing a resource with that
+    // content id.
+    bool reusing_raster_resource = raster_content_id_ != 0;
     sequence_ = worker_pool_->PlaybackAndScheduleCopyOnWorkerThread(
-        reusing_raster_resource_, lock_.Pass(), raster_resource_.get(),
+        reusing_raster_resource, lock_.Pass(), raster_resource_.get(),
         output_resource_, raster_source, raster_full_rect, raster_dirty_rect,
         scale);
+    // Store the content id of the resource to return to the pool.
+    raster_content_id_ = new_content_id;
   }
 
  private:
@@ -89,9 +91,7 @@ class RasterBufferImpl : public RasterBuffer {
   ResourceProvider* resource_provider_;
   ResourcePool* resource_pool_;
   const Resource* output_resource_;
-  uint64_t new_content_id_;
-  uint64_t previous_content_id_;
-  bool reusing_raster_resource_;
+  uint64_t raster_content_id_;
   scoped_ptr<ScopedResource> raster_resource_;
   scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> lock_;
   CopySequenceNumber sequence_;
@@ -295,13 +295,15 @@ ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat() {
 
 scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource,
-    uint64_t new_content_id,
+    uint64_t resource_content_id,
     uint64_t previous_content_id) {
+  // TODO(danakj): If resource_content_id != 0, we only need to copy/upload
+  // the dirty rect.
   DCHECK_EQ(resource->format(), resource_provider_->best_texture_format());
   return make_scoped_ptr<RasterBuffer>(
       new RasterBufferImpl(this, resource_provider_, resource_pool_,
                            resource_provider_->best_texture_format(), resource,
-                           new_content_id, previous_content_id));
+                           previous_content_id));
 }
 
 void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
diff --git a/cc/raster/one_copy_tile_task_worker_pool.h b/cc/raster/one_copy_tile_task_worker_pool.h
index 7b76c27..610530d 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.h
+++ b/cc/raster/one_copy_tile_task_worker_pool.h
@@ -55,7 +55,7 @@ class CC_EXPORT OneCopyTileTaskWorkerPool : public TileTaskWorkerPool,
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
-      uint64_t new_content_id,
+      uint64_t resource_content_id,
       uint64_t previous_content_id) override;
   void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
diff --git a/cc/raster/pixel_buffer_tile_task_worker_pool.cc b/cc/raster/pixel_buffer_tile_task_worker_pool.cc
index f6c0abb..f6936a7 100644
--- a/cc/raster/pixel_buffer_tile_task_worker_pool.cc
+++ b/cc/raster/pixel_buffer_tile_task_worker_pool.cc
@@ -38,6 +38,7 @@ class RasterBufferImpl : public RasterBuffer {
   void Playback(const RasterSource* raster_source,
                 const gfx::Rect& raster_full_rect,
                 const gfx::Rect& raster_dirty_rect,
+                uint64_t new_content_id,
                 float scale) override {
     if (!memory_)
       return;
@@ -314,7 +315,7 @@ ResourceFormat PixelBufferTileTaskWorkerPool::GetResourceFormat() {
 
 scoped_ptr<RasterBuffer> PixelBufferTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource,
-    uint64_t new_content_id,
+    uint64_t resource_content_id,
     uint64_t previous_content_id) {
   return make_scoped_ptr<RasterBuffer>(
       new RasterBufferImpl(resource_provider_, resource));
diff --git a/cc/raster/pixel_buffer_tile_task_worker_pool.h b/cc/raster/pixel_buffer_tile_task_worker_pool.h
index 79cb306..f26245f 100644
--- a/cc/raster/pixel_buffer_tile_task_worker_pool.h
+++ b/cc/raster/pixel_buffer_tile_task_worker_pool.h
@@ -51,7 +51,7 @@ class CC_EXPORT PixelBufferTileTaskWorkerPool : public TileTaskWorkerPool,
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
-      uint64_t new_content_id,
+      uint64_t resource_content_id,
       uint64_t previous_content_id) override;
   void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
diff --git a/cc/raster/raster_buffer.h b/cc/raster/raster_buffer.h
index 2b63806..5af4dec 100644
--- a/cc/raster/raster_buffer.h
+++ b/cc/raster/raster_buffer.h
@@ -19,6 +19,7 @@ class CC_EXPORT RasterBuffer {
   virtual void Playback(const RasterSource* raster_source,
                         const gfx::Rect& raster_full_rect,
                         const gfx::Rect& raster_dirty_rect,
+                        uint64_t new_content_id,
                         float scale) = 0;
 };
 
diff --git a/cc/raster/tile_task_runner.h b/cc/raster/tile_task_runner.h
index 2b244f3..a4c7d88 100644
--- a/cc/raster/tile_task_runner.h
+++ b/cc/raster/tile_task_runner.h
@@ -22,7 +22,7 @@ class CC_EXPORT TileTaskClient {
  public:
   virtual scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
-      uint64_t new_content_id,
+      uint64_t resource_content_id,
       uint64_t previous_content_id) = 0;
   virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) = 0;
 
diff --git a/cc/raster/tile_task_worker_pool_unittest.cc b/cc/raster/tile_task_worker_pool_unittest.cc
index 8523f50..09db4a7 100644
--- a/cc/raster/tile_task_worker_pool_unittest.cc
+++ b/cc/raster/tile_task_worker_pool_unittest.cc
@@ -69,8 +69,9 @@ class TestRasterTaskImpl : public RasterTask {
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
+    uint64_t new_content_id = 0;
     raster_buffer_->Playback(picture_pile_.get(), gfx::Rect(1, 1),
-                             gfx::Rect(1, 1), 1.0);
+                             gfx::Rect(1, 1), new_content_id, 1.f);
   }
 
   // Overridden from TileTask:
diff --git a/cc/raster/zero_copy_tile_task_worker_pool.cc b/cc/raster/zero_copy_tile_task_worker_pool.cc
index d5a2e8e..dff2746 100644
--- a/cc/raster/zero_copy_tile_task_worker_pool.cc
+++ b/cc/raster/zero_copy_tile_task_worker_pool.cc
@@ -27,6 +27,7 @@ class RasterBufferImpl : public RasterBuffer {
   void Playback(const RasterSource* raster_source,
                 const gfx::Rect& raster_full_rect,
                 const gfx::Rect& raster_dirty_rect,
+                uint64_t new_content_id,
                 float scale) override {
     gfx::GpuMemoryBuffer* gpu_memory_buffer = lock_.GetGpuMemoryBuffer();
     if (!gpu_memory_buffer)
@@ -178,7 +179,7 @@ ResourceFormat ZeroCopyTileTaskWorkerPool::GetResourceFormat() {
 
 scoped_ptr<RasterBuffer> ZeroCopyTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource,
-    uint64_t new_content_id,
+    uint64_t resource_content_id,
     uint64_t previous_content_id) {
   return make_scoped_ptr<RasterBuffer>(
       new RasterBufferImpl(resource_provider_, resource));
diff --git a/cc/raster/zero_copy_tile_task_worker_pool.h b/cc/raster/zero_copy_tile_task_worker_pool.h
index 149f91f..9714119 100644
--- a/cc/raster/zero_copy_tile_task_worker_pool.h
+++ b/cc/raster/zero_copy_tile_task_worker_pool.h
@@ -43,7 +43,7 @@ class CC_EXPORT ZeroCopyTileTaskWorkerPool : public TileTaskWorkerPool,
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
-      uint64_t new_content_id,
+      uint64_t resource_content_id,
       uint64_t previous_content_id) override;
   void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index bf44d2e..53f88da 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -52,7 +52,7 @@ class FakeTileTaskRunnerImpl : public TileTaskRunner, public TileTaskClient {
   // Overridden from TileTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       const Resource* resource,
-      uint64_t new_content_id,
+      uint64_t resource_content_id,
       uint64_t previous_content_id) override {
     return nullptr;
   }
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index e56230d..cf6981e 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -48,6 +48,7 @@ class RasterTaskImpl : public RasterTask {
       const void* tile,
       uint64_t new_content_id,
       uint64_t previous_content_id,
+      uint64_t resource_content_id,
       int source_frame_number,
       bool analyze_picture,
       const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>&
@@ -63,6 +64,7 @@ class RasterTaskImpl : public RasterTask {
         tile_(tile),
         new_content_id_(new_content_id),
         previous_content_id_(previous_content_id),
+        resource_content_id_(resource_content_id),
         source_frame_number_(source_frame_number),
         analyze_picture_(analyze_picture),
         reply_(reply) {}
@@ -86,8 +88,8 @@ class RasterTaskImpl : public RasterTask {
   // Overridden from TileTask:
   void ScheduleOnOriginThread(TileTaskClient* client) override {
     DCHECK(!raster_buffer_);
-    raster_buffer_ = client->AcquireBufferForRaster(resource(), new_content_id_,
-                                                    previous_content_id_);
+    raster_buffer_ = client->AcquireBufferForRaster(
+        resource(), resource_content_id_, previous_content_id_);
   }
   void CompleteOnOriginThread(TileTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
@@ -122,7 +124,8 @@ class RasterTaskImpl : public RasterTask {
     DCHECK(raster_source);
 
     raster_buffer_->Playback(raster_source_.get(), content_rect_,
-                             invalid_content_rect_, contents_scale_);
+                             invalid_content_rect_, new_content_id_,
+                             contents_scale_);
   }
 
   RasterSource::SolidColorAnalysis analysis_;
@@ -135,6 +138,7 @@ class RasterTaskImpl : public RasterTask {
   const void* tile_;
   uint64_t new_content_id_;
   uint64_t previous_content_id_;
+  uint64_t resource_content_id_;
   int source_frame_number_;
   bool analyze_picture_;
   const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>
@@ -669,9 +673,23 @@ scoped_refptr<ImageDecodeTask> TileManager::CreateImageDecodeTask(
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
-  scoped_ptr<ScopedResource> resource =
-      resource_pool_->AcquireResource(tile->desired_texture_size(),
-                                      tile_task_runner_->GetResourceFormat());
+  uint64_t resource_content_id = 0;
+  scoped_ptr<ScopedResource> resource;
+  if (tile->invalidated_id()) {
+    // TODO(danakj): For resources that are in use, we should still grab them
+    // and copy from them instead of rastering everything. crbug.com/492754
+    resource =
+        resource_pool_->TryAcquireResourceWithContentId(tile->invalidated_id());
+  }
+  if (resource) {
+    resource_content_id = tile->invalidated_id();
+    DCHECK_EQ(tile_task_runner_->GetResourceFormat(), resource->format());
+    DCHECK_EQ(tile->desired_texture_size().ToString(),
+              resource->size().ToString());
+  } else {
+    resource = resource_pool_->AcquireResource(
+        tile->desired_texture_size(), tile_task_runner_->GetResourceFormat());
+  }
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
@@ -702,7 +720,8 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
       tile->invalidated_content_rect(), tile->contents_scale(),
       prioritized_tile.priority().resolution, tile->layer_id(),
       static_cast<const void*>(tile), tile->id(), tile->invalidated_id(),
-      tile->source_frame_number(), tile->use_picture_analysis(),
+      resource_content_id, tile->source_frame_number(),
+      tile->use_picture_analysis(),
       base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
                  tile->id(), base::Passed(&resource)),
       &decode_tasks));
@@ -742,7 +761,7 @@ void TileManager::OnRasterTaskCompleted(
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
-    resource_pool_->ReleaseResource(resource.Pass(), Tile::Id(0));
+    resource_pool_->ReleaseResource(resource.Pass(), tile->invalidated_id());
     return;
   }
 
@@ -760,9 +779,9 @@ void TileManager::UpdateTileDrawInfo(
   if (analysis.is_solid_color) {
     draw_info.set_solid_color(analysis.solid_color);
     if (resource) {
-      // Pass no tile id here because the tile is solid color so we did not
+      // Pass the old tile id here because the tile is solid color so we did not
       // raster anything into the tile resource.
-      resource_pool_->ReleaseResource(resource.Pass(), Tile::Id(0));
+      resource_pool_->ReleaseResource(resource.Pass(), tile->invalidated_id());
     }
   } else {
     DCHECK(resource);
diff --git a/cc/trees/layer_tree_host_pixeltest_tiles.cc b/cc/trees/layer_tree_host_pixeltest_tiles.cc
index eef2d2d..4c3797b 100644
--- a/cc/trees/layer_tree_host_pixeltest_tiles.cc
+++ b/cc/trees/layer_tree_host_pixeltest_tiles.cc
@@ -20,6 +20,7 @@ namespace {
 enum RasterMode {
   PARTIAL_ONE_COPY,
   FULL_ONE_COPY,
+  BITMAP,
 };
 
 class LayerTreeHostTilesPixelTest : public LayerTreePixelTest {
@@ -38,6 +39,9 @@ class LayerTreeHostTilesPixelTest : public LayerTreePixelTest {
         settings->use_zero_copy = false;
         settings->use_persistent_map_for_gpu_memory_buffers = false;
         break;
+      case BITMAP:
+        // This is done via context creation. No settings to change here!
+        break;
     }
   }
 
@@ -64,6 +68,8 @@ class LayerTreeHostTilesPixelTest : public LayerTreePixelTest {
       case FULL_ONE_COPY:
         test_type = PIXEL_TEST_GL;
         break;
+      case BITMAP:
+        test_type = PIXEL_TEST_SOFTWARE;
     }
 
     if (threaded)
@@ -182,6 +188,13 @@ TEST_F(LayerTreeHostTilesTestPartialInvalidation,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_flipped.png")));
 }
 
+TEST_F(LayerTreeHostTilesTestPartialInvalidation,
+       PartialRaster_SingleThread_Software) {
+  RunRasterPixelTest(
+      false, BITMAP, picture_layer_,
+      base::FilePath(FILE_PATH_LITERAL("blue_yellow_partial_flipped.png")));
+}
+
 }  // namespace
 }  // namespace cc