[WebRTC] Add ScreenCapturerDifferWrapper to share Differ across ScreenCapturers

webrtc/modules/desktop_capture/differ_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/modules/desktop_capture/desktop_region.h"
+#include "webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "webrtc/modules/desktop_capture/differ.h"
 #include "webrtc/modules/desktop_capture/differ_block.h"
 
 namespace webrtc {
 
 // 96x96 screen gives a 4x4 grid of blocks.
 const int kScreenWidth= 96;
 const int kScreenHeight = 96;
 
 // To test partial blocks, we need a width and height that are not multiples
@@ skipping 22 matching lines @@
     curr_.reset(new uint8_t[buffer_size_]);
     memset(curr_.get(), 0, buffer_size_);
   }
 
   void ClearBuffer(uint8_t* buffer) {
     memset(buffer, 0, buffer_size_);
   }
 
   // Here in DifferTest so that tests can access private methods of Differ.
   void MarkDirtyBlocks(const uint8_t* prev_buffer, const uint8_t* curr_buffer) {
-    differ_->MarkDirtyBlocks(prev_buffer, curr_buffer);
+    differ_->MarkDirtyBlocks(prev_buffer, curr_buffer,
+                             DesktopRect::MakeWH(width_, height_));
   }
 
   void MergeBlocks(DesktopRegion* dirty) {
     differ_->MergeBlocks(dirty);
   }
 
   // Convenience method to count rectangles in a region.
   int RegionRectCount(const DesktopRegion& region) {
     int count = 0;
     for (DesktopRegion::Iterator iter(region);
@@ skipping 83 matching lines @@
   }
 
   // Verify that |region| contains a rectangle defined by |x|, |y|, |width| and
   // |height|.
   // |x|, |y|, |width| and |height| are specified in block (not pixel) units.
   bool CheckDirtyRegionContainsRect(const DesktopRegion& region,
                                     int x, int y,
                                     int width, int height) {
     DesktopRect r =
       DesktopRect::MakeXYWH(x * kBlockSize, y * kBlockSize,
-                                    width * kBlockSize, height * kBlockSize);
+                            width * kBlockSize, height * kBlockSize);
     for (DesktopRegion::Iterator i(region); !i.IsAtEnd(); i.Advance()) {
       if (i.rect().equals(r))
         return true;
     }
     return false;
   }
 
+  bool CheckDirtyRegionContainsPartialRect(const DesktopRegion& region,

[Jamie, 2016/08/03 23:52:26]

"Partial" is used in the differ to refer to sub-kBlockSize blocks, so I'm
surprised to see the multiplications in this function. How is "partial" being
used here?

[Hzj_jie, 2016/08/04 02:28:07]

The "partial" here means one of the dirty regions is part of the input block (x,
y) -> (x + width, y + height). And this function is used only in the case, where
the resolution of the screen is not an integral multiple of kBlockSize. (At the
bottom of this file.)

You know, I am not a native speaker, so feel free to suggest any more
appropriate name.

+                                           int x, int y,
+                                           int width, int height) {
+    DesktopRect r =
+      DesktopRect::MakeXYWH(x * kBlockSize, y * kBlockSize,
+                            width * kBlockSize, height * kBlockSize);
+    for (DesktopRegion::Iterator i(region); !i.IsAtEnd(); i.Advance()) {
+      if (r.ContainsRect(i.rect()))
+        return true;
+    }
+    return false;
+  }
+
   // 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.
   bool MarkBlocksAndCheckMerge(int x_origin, int y_origin,
                                int width, int height) {
     ClearDiffInfo();
     MarkBlocks(x_origin, y_origin, width, height);
 
     DesktopRegion dirty;
     MergeBlocks(&dirty);
@@ skipping 465 matching lines @@
   MarkBlocks(1, 2, 1, 1);
 
   dirty.Clear();
   MergeBlocks(&dirty);
 
   ASSERT_EQ(2, RegionRectCount(dirty));
   ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 2, 2));
   ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 2, 1, 1));
 }
 
+TEST_F(DifferTest, ScreenSizeWithEmptyHints) {
+  InitDiffer(kScreenWidth, kScreenHeight);
+  DesktopRegion dirty;
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), DesktopRegion(),
+                                    &dirty);
+  ASSERT_EQ(0, RegionRectCount(dirty));
+}
+
+TEST_F(DifferTest, OneDirtyBlockWithHints) {
+  // Initialize a 3 x 3 screen.
+  // +---+---+---+
+  // |   |   |   |
+  // +---+---+---+
+  // |   | X |   |
+  // +---+---+---+
+  // |   |   |   |
+  // +---+---+---+
+  InitDiffer(kScreenWidth, kScreenHeight);
+  WritePixel(curr_.get(), kBlockSize, kBlockSize, 0x11223344);
+  DesktopRegion dirty;
+  dirty.AddRect(
+      DesktopRect::MakeXYWH(kBlockSize, kBlockSize, kBlockSize, kBlockSize));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(1, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 1, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize >> 1, kBlockSize >> 1,
+                                      kBlockSize, kBlockSize));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 1.5, kBlockSize * 1.5,
+                                      kBlockSize >> 1, kBlockSize >> 1));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(1, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 1, 1, 1));
+}
+
+TEST_F(DifferTest, MultipleDirtyBlocksWithHints) {
+  // Initialize a 3 x 3 screen.
+  // +---+---+---+
+  // |   |   |   |
+  // +---+---+---+
+  // |   | X |   |
+  // +---+---+---+
+  // |   |   | X |
+  // +---+---+---+
+  InitDiffer(kScreenWidth, kScreenHeight);
+  WritePixel(curr_.get(), kBlockSize, kBlockSize, 0x11223344);
+  WritePixel(curr_.get(), kBlockSize * 2, kBlockSize * 2, 0x11223344);
+  DesktopRegion dirty;
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize, kBlockSize,
+                                      kBlockSize * 2, kBlockSize * 2));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 1, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 2, 1, 1));
+
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 1, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 2, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize * 2, kBlockSize * 2));
+  dirty.AddRect(
+      DesktopRect::MakeXYWH(0, kBlockSize * 2, kBlockSize * 3, kBlockSize));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 1, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 2, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize, kBlockSize));
+  dirty.AddRect(
+      DesktopRect::MakeXYWH(0, kBlockSize, kBlockSize * 2, kBlockSize));
+  dirty.AddRect(
+      DesktopRect::MakeXYWH(0, kBlockSize * 2, kBlockSize * 3, kBlockSize));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 1, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 2, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize >> 1, kBlockSize >> 1,
+                                      kBlockSize, kBlockSize));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 1.5, kBlockSize,
+                                      kBlockSize * 1.5, kBlockSize * 2));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 1, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 2, 1, 1));
+}
+
+TEST_F(DifferTest, MultipleDirtyBlocksWithHints2) {
+  // Initialize a 4 x 4 screen.
+  // +---+---+---+---+
+  // | X |   |   |   |
+  // +---+---+---+---+
+  // |   |   |   |   |
+  // +---+---+---+---+
+  // |   |   |   |   |
+  // +---+---+---+---+
+  // |   |   |   | X |
+  // +---+---+---+---+
+  InitDiffer(4 * kBlockSize, 4 * kBlockSize);
+  WritePixel(curr_.get(), 0, 0, 0x11223344);
+  WritePixel(curr_.get(), kBlockSize * 3, kBlockSize * 3, 0x11223344);
+  DesktopRegion dirty;
+  dirty.AddRect(
+      DesktopRect::MakeXYWH(0, 0, kBlockSize * 4, kBlockSize * 4));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 3, 3, 1, 1));
+
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 3, 3, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize, kBlockSize));
+  dirty.AddRect(
+      DesktopRect::MakeXYWH(kBlockSize, kBlockSize, kBlockSize, kBlockSize));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 3, kBlockSize * 3,
+                                      kBlockSize, kBlockSize));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 3, 3, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize * 2, kBlockSize * 2));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 2, kBlockSize * 2,
+                                      kBlockSize * 2, kBlockSize * 2));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 3, 3, 1, 1));
+
+  dirty.Clear();
+  // Note, even the hints does not cover entire block, we should still be able
+  // to detect it.
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize >> 1, kBlockSize >> 1));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 2.5, kBlockSize * 2.5,
+                                      kBlockSize, kBlockSize));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 3, 3, 1, 1));
+}
+
+TEST_F(DifferTest, PartialScreenSizeWithHints) {
+  // Initialize a 4 x 4 screen, the right and bottom blocks do not have a
+  // kBlockSize size.
+  // +---+---+---+---+
+  // | X |   |   |   |
+  // +---+---+---+---+
+  // |   |   |   |   |
+  // +---+---+---+---+
+  // |   |   |   |   |
+  // +---+---+---+---+
+  // |   |   |   | X |
+  // +---+---+---+---+
+  InitDiffer(4 * kBlockSize - (kBlockSize >> 1),
+             4 * kBlockSize - (kBlockSize >> 1));
+  WritePixel(curr_.get(), 0, 0, 0x11223344);
+  WritePixel(curr_.get(), kBlockSize * 3, kBlockSize * 3, 0x11223344);
+  DesktopRegion dirty;
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0,
+                                      4 * kBlockSize - (kBlockSize >> 1),
+                                      4 * kBlockSize - (kBlockSize >> 1)));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsPartialRect(dirty, 3, 3, 1, 1));
+
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsPartialRect(dirty, 3, 3, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize, kBlockSize));
+  dirty.AddRect(
+      DesktopRect::MakeXYWH(kBlockSize, kBlockSize, kBlockSize, kBlockSize));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 3, kBlockSize * 3,
+                                      kBlockSize, kBlockSize));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsPartialRect(dirty, 3, 3, 1, 1));
+
+  dirty.Clear();
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize * 2, kBlockSize * 2));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 2, kBlockSize * 2,
+                                      kBlockSize * 1.5, kBlockSize * 1.5));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsPartialRect(dirty, 3, 3, 1, 1));
+
+  dirty.Clear();
+  // Note, even the hints does not cover entire block, we should still be able
+  // to detect it.
+  dirty.AddRect(DesktopRect::MakeXYWH(0, 0, kBlockSize >> 1, kBlockSize >> 1));
+  dirty.AddRect(DesktopRect::MakeXYWH(kBlockSize * 2.5, kBlockSize * 2.5,
+                                      kBlockSize, kBlockSize));
+  differ_->CalcDirtyRegionWithHints(prev_.get(), curr_.get(), dirty, &dirty);
+  ASSERT_EQ(2, RegionRectCount(dirty));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 1, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsPartialRect(dirty, 3, 3, 1, 1));
+}
+
 }  // namespace webrtc