Initial pass at integrating Differ into the chromoting host code....

remoting/host/differ_unittest.cc

 // Copyright (c) 2010 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 "base/scoped_ptr.h"
 #include "remoting/host/differ.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace remoting {
 
 // 96x96 screen gives a 3x3 grid of blocks.
-const int kScreenWidth = 96;
+const int kScreenWidth= 96;
 const int kScreenHeight = 96;
 const int kBytesPerPixel = 3;
+const int kBytesPerRow = (kBytesPerPixel * kScreenWidth);
 
 class DifferTest : public testing::Test {
  public:
   DifferTest() {
   }
 
  protected:
   virtual void SetUp() {
-    InitDiffer(kScreenWidth, kScreenHeight, kBytesPerPixel);
+    InitDiffer(kScreenWidth, kScreenHeight, kBytesPerPixel, kBytesPerRow);
   }
 
-  void InitDiffer(int width, int height, int bpp) {
+  void InitDiffer(int width, int height, int bpp, int stride) {
     width_ = width;
     height_ = height;
     bytes_per_pixel_ = bpp;
-
-    stride_ = width_ * bytes_per_pixel_;
+    stride_ = stride;
     buffer_size_ = width_ * height_ * bytes_per_pixel_;
 
-    differ_.reset(new Differ(width_, height_, bytes_per_pixel_));
+    differ_.reset(new Differ(width_, height_, bytes_per_pixel_, stride_));
 
     prev_.reset(new uint8[buffer_size_]);
     memset(prev_.get(), 0, buffer_size_);
 
     curr_.reset(new uint8[buffer_size_]);
     memset(curr_.get(), 0, buffer_size_);
   }
 
   void ClearBuffer(uint8* buffer) {
     memset(buffer, 0, buffer_size_);
@@ skipping 74 matching lines @@
     for (int y = 0; y < height; y++) {
       for (int x = 0; x < width; x++) {
         SetDiffInfo(x_origin + x, y_origin + y, 1);
       }
     }
   }
 
   // Verify that the given dirty rect matches the expected |x|, |y|, |width|
   // and |height|.
   // |x|, |y|, |width| and |height| are specified in block (not pixel) units.
-  void CheckDirtyRect(const gfx::Rect& rect, int x, int y,
+  void CheckDirtyRect(const InvalidRects& rects, int x, int y,
                       int width, int height) {
-    EXPECT_EQ(x * kBlockSize, rect.x());
-    EXPECT_EQ(y * kBlockSize, rect.y());
-    EXPECT_EQ(width * kBlockSize, rect.width());
-    EXPECT_EQ(height * kBlockSize, rect.height());
+    gfx::Rect r(x * kBlockSize, y * kBlockSize,
+                width * kBlockSize, height * kBlockSize);
+    EXPECT_TRUE(rects.find(r) != rects.end());
   }
 
   // Mark the range of blocks specified and then verify that they are
   // merged correctly.
   // Only one rectangular region of blocks can be checked with this routine.
   void MarkBlocksAndCheckMerge(int x_origin, int y_origin,
                                int width, int height) {
     ClearDiffInfo();
     MarkBlocks(x_origin, y_origin, width, height);
 
-    scoped_ptr<DirtyRects> dirty(new DirtyRects());
+    scoped_ptr<InvalidRects> dirty(new InvalidRects());
     differ_->MergeBlocks(dirty.get());
 
     ASSERT_EQ(1UL, dirty->size());
-    CheckDirtyRect(dirty->at(0), x_origin, y_origin, width, height);
+    CheckDirtyRect(*dirty.get(), x_origin, y_origin, width, height);
   }
 
   // The differ class we're testing.
   scoped_ptr<Differ> differ_;
 
   // Screen/buffer info.
   int width_;
   int height_;
   int bytes_per_pixel_;
   int stride_;
@@ skipping 102 matching lines @@
   // |   |   |   | _ |
   // +---+---+---+---+
   // |   |   |   | _ |
   // +---+---+---+---+
   // |   |   |   | _ |
   // +---+---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
 
-  scoped_ptr<DirtyRects> dirty(new DirtyRects());
+  scoped_ptr<InvalidRects> dirty(new InvalidRects());
   differ_->MergeBlocks(dirty.get());
 
   EXPECT_EQ(0UL, dirty->size());
 }
 
 TEST_F(DifferTest, MergeBlocks_SingleBlock) {
   // Mark a single block and make sure that there is a single merged
   // rect with the correct bounds.
   for (int y = 0; y < GetDiffInfoHeight() - 1; y++) {
     for (int x = 0; x < GetDiffInfoWidth() - 1; x++) {
@@ skipping 126 matching lines @@
   // +---+---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   MarkBlocksAndCheckMerge(0, 0, 3, 3);
 }
 
 // This tests marked regions that require more than 1 single dirty rect.
 // The exact rects returned depend on the current implementation, so these
 // may need to be updated if we modify how we merge blocks.
 TEST_F(DifferTest, MergeBlocks_MultiRect) {
-  scoped_ptr<DirtyRects> dirty;
+  scoped_ptr<InvalidRects> dirty;
 
   // +---+---+---+---+      +---+---+---+
   // |   | X |   | _ |      |   | 0 |   |
   // +---+---+---+---+      +---+---+---+
   // | X |   |   | _ |      | 1 |   |   |
   // +---+---+---+---+  =>  +---+---+---+
   // |   |   | X | _ |      |   |   | 2 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(1, 0, 1, 1);
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 2, 1, 1);
 
-  dirty.reset(new DirtyRects());
+  dirty.reset(new InvalidRects());
   differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(3UL, dirty->size());
-  CheckDirtyRect(dirty->at(0), 1, 0, 1, 1);
-  CheckDirtyRect(dirty->at(1), 0, 1, 1, 1);
-  CheckDirtyRect(dirty->at(2), 2, 2, 1, 1);
+  CheckDirtyRect(*dirty.get(), 1, 0, 1, 1);
+  CheckDirtyRect(*dirty.get(), 0, 1, 1, 1);
+  CheckDirtyRect(*dirty.get(), 2, 2, 1, 1);
 
   // +---+---+---+---+      +---+---+---+
   // |   |   | X | _ |      |   |   | 0 |
   // +---+---+---+---+      +---+---+   +
   // | X | X | X | _ |      | 1   1 | 0 |
   // +---+---+---+---+  =>  +       +   +
   // | X | X | X | _ |      | 1   1 | 0 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(2, 0, 1, 3);
   MarkBlocks(0, 1, 2, 2);
 
-  dirty.reset(new DirtyRects());
+  dirty.reset(new InvalidRects());
   differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(2UL, dirty->size());
-  CheckDirtyRect(dirty->at(0), 2, 0, 1, 3);
-  CheckDirtyRect(dirty->at(1), 0, 1, 2, 2);
+  CheckDirtyRect(*dirty.get(), 2, 0, 1, 3);
+  CheckDirtyRect(*dirty.get(), 0, 1, 2, 2);
 
   // +---+---+---+---+      +---+---+---+
   // |   |   |   | _ |      |   |   |   |
   // +---+---+---+---+      +---+---+---+
   // | X |   | X | _ |      | 0 |   | 1 |
   // +---+---+---+---+  =>  +   +---+   +
   // | X | X | X | _ |      | 0 | 2 | 1 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 1, 1, 1);
   MarkBlocks(0, 2, 3, 1);
 
-  dirty.reset(new DirtyRects());
+  dirty.reset(new InvalidRects());
   differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(3UL, dirty->size());
-  CheckDirtyRect(dirty->at(0), 0, 1, 1, 2);
-  CheckDirtyRect(dirty->at(1), 2, 1, 1, 2);
-  CheckDirtyRect(dirty->at(2), 1, 2, 1, 1);
+  CheckDirtyRect(*dirty.get(), 0, 1, 1, 2);
+  CheckDirtyRect(*dirty.get(), 2, 1, 1, 2);
+  CheckDirtyRect(*dirty.get(), 1, 2, 1, 1);
 
   // +---+---+---+---+      +---+---+---+
   // | X | X | X | _ |      | 0   0   0 |
   // +---+---+---+---+      +---+---+---+
   // | X |   | X | _ |      | 1 |   | 2 |
   // +---+---+---+---+  =>  +   +---+   +
   // | X | X | X | _ |      | 1 | 3 | 2 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(0, 0, 3, 1);
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 1, 1, 1);
   MarkBlocks(0, 2, 3, 1);
 
-  dirty.reset(new DirtyRects());
+  dirty.reset(new InvalidRects());
   differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(4UL, dirty->size());
-  CheckDirtyRect(dirty->at(0), 0, 0, 3, 1);
-  CheckDirtyRect(dirty->at(1), 0, 1, 1, 2);
-  CheckDirtyRect(dirty->at(2), 2, 1, 1, 2);
-  CheckDirtyRect(dirty->at(3), 1, 2, 1, 1);
+  CheckDirtyRect(*dirty.get(), 0, 0, 3, 1);
+  CheckDirtyRect(*dirty.get(), 0, 1, 1, 2);
+  CheckDirtyRect(*dirty.get(), 2, 1, 1, 2);
+  CheckDirtyRect(*dirty.get(), 1, 2, 1, 1);
 
   // +---+---+---+---+      +---+---+---+
   // | X | X |   | _ |      | 0   0 |   |
   // +---+---+---+---+      +       +---+
   // | X | X |   | _ |      | 0   0 |   |
   // +---+---+---+---+  =>  +---+---+---+
   // |   | X |   | _ |      |   | 1 |   |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(0, 0, 2, 2);
   MarkBlocks(1, 2, 1, 1);
 
-  dirty.reset(new DirtyRects());
+  dirty.reset(new InvalidRects());
   differ_->MergeBlocks(dirty.get());
 
   ASSERT_EQ(2UL, dirty->size());
-  CheckDirtyRect(dirty->at(0), 0, 0, 2, 2);
-  CheckDirtyRect(dirty->at(1), 1, 2, 1, 1);
+  CheckDirtyRect(*dirty.get(), 0, 0, 2, 2);
+  CheckDirtyRect(*dirty.get(), 1, 2, 1, 1);
 }
 
 }  // namespace remoting