Switch over to using SkRegions to calculate dirty areas.

remoting/host/differ.cc

 // Copyright (c) 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 "remoting/host/differ.h"
 
 #include "base/logging.h"
 #include "remoting/host/differ_block.h"
 
 namespace remoting {
 
 Differ::Differ(int width, int height, int bpp, int stride) {
   // Dimensions of screen.
   width_ = width;
   height_ = height;
   bytes_per_pixel_ = bpp;
   bytes_per_row_ = stride;
 
   // Calc number of blocks (full and partial) required to cover entire image.
   // One additional row/column is added as a boundary on the right & bottom.
   diff_info_width_ = ((width_ + kBlockSize - 1) / kBlockSize) + 1;
   diff_info_height_ = ((height_ + kBlockSize - 1) / kBlockSize) + 1;
   diff_info_size_ = diff_info_width_ * diff_info_height_ * sizeof(DiffInfo);
   diff_info_.reset(new DiffInfo[diff_info_size_]);
 }
 
 Differ::~Differ() {}
 
-void Differ::CalcDirtyRects(const void* prev_buffer, const void* curr_buffer,
-                            InvalidRects* rects) {
-  if (!rects) {
+void Differ::CalcDirtyRegion(const void* prev_buffer, const void* curr_buffer,
+                             SkRegion* region) {
+  if (!region) {
     return;
   }
-  rects->clear();
+  region->setEmpty();
 
   if (!prev_buffer || !curr_buffer) {
     return;
   }
 
   // Identify all the blocks that contain changed pixels.
   MarkDirtyBlocks(prev_buffer, curr_buffer);
 
   // Now that we've identified the blocks that have changed, merge adjacent
   // blocks to minimize the number of rects that we return.
-  MergeBlocks(rects);
+  MergeBlocks(region);
 }
 
 void Differ::MarkDirtyBlocks(const void* prev_buffer, const void* curr_buffer) {
   memset(diff_info_.get(), 0, diff_info_size_);
 
   // Calc number of full blocks.
   int x_full_blocks = width_ / kBlockSize;
   int y_full_blocks = height_ / kBlockSize;
 
   // Calc size of partial blocks which may be present on right and bottom edge.
@@ skipping 68 matching lines @@
   int width_bytes = width * bytes_per_pixel_;
   for (int y = 0; y < height; y++) {
     if (memcmp(prev_buffer, curr_buffer, width_bytes) != 0)
       return 1;
     prev_buffer += bytes_per_row_;
     curr_buffer += bytes_per_row_;
   }
   return 0;
 }
 
-void Differ::MergeBlocks(InvalidRects* rects) {
-  DCHECK(rects);
-  rects->clear();
+void Differ::MergeBlocks(SkRegion* region) {
+  DCHECK(region);
+  region->setEmpty();
 
   uint8* diff_info_row_start = static_cast<uint8*>(diff_info_.get());
   int diff_info_stride = diff_info_width_ * sizeof(DiffInfo);
 
   for (int y = 0; y < diff_info_height_; y++) {
     uint8* diff_info = diff_info_row_start;
     for (int x = 0; x < diff_info_width_; x++) {
       if (*diff_info != 0) {
         // We've found a modified block. Look at blocks to the right and below
         // to group this block with as many others as we can.
@@ skipping 41 matching lines @@
 
         // Add rect to list of dirty rects.
         width *= kBlockSize;
         if (left + width > width_) {
           width = width_ - left;
         }
         height *= kBlockSize;
         if (top + height > height_) {
           height = height_ - top;
         }
-        rects->insert(gfx::Rect(left, top, width, height));
+        region->op(SkIRect::MakeXYWH(left, top, width, height),
+                   SkRegion::kUnion_Op);
       }
 
       // Increment to next block in this row.
       diff_info++;
     }
 
     // Go to start of next row.
     diff_info_row_start += diff_info_stride;
   }
 }
 
 }  // namespace remoting