Use webrtc::DesktopCapturer for screen capturer implementation.

media/video/capture/screen/differ_unittest.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 "base/memory/scoped_ptr.h"
 #include "media/video/capture/screen/differ.h"
 #include "media/video/capture/screen/differ_block.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
@@ skipping 31 matching lines @@
 
   void ClearBuffer(uint8* buffer) {
     memset(buffer, 0, buffer_size_);
   }
 
   // Here in DifferTest so that tests can access private methods of Differ.
   void MarkDirtyBlocks(const void* prev_buffer, const void* curr_buffer) {
     differ_->MarkDirtyBlocks(prev_buffer, curr_buffer);
   }
 
-  void MergeBlocks(SkRegion* dirty) {
+  void MergeBlocks(webrtc::DesktopRegion* dirty) {
     differ_->MergeBlocks(dirty);
   }
 
   // Convenience method to count rectangles in a region.
-  int RegionRectCount(const SkRegion& region) {
+  int RegionRectCount(const webrtc::DesktopRegion& region) {
     int count = 0;
-    for(SkRegion::Iterator iter(region); !iter.done(); iter.next()) {
+    for (webrtc::DesktopRegion::Iterator iter(region);
+         !iter.IsAtEnd(); iter.Advance()) {
       ++count;
     }
     return count;
   }
 
   // Convenience wrapper for Differ's DiffBlock that calculates the appropriate
   // offset to the start of the desired block.
   DiffInfo DiffBlock(int block_x, int block_y) {
     // Offset from upper-left of buffer to upper-left of requested block.
     int block_offset = ((block_y * stride_) + (block_x * bytes_per_pixel_))
@@ skipping 67 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 |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 SkRegion& region, int x, int y,
+  bool CheckDirtyRegionContainsRect(const webrtc::DesktopRegion& region,
+                                    int x, int y,
                                     int width, int height) {
-    SkIRect r = SkIRect::MakeXYWH(x * kBlockSize, y * kBlockSize,
-                                  width * kBlockSize, height * kBlockSize);
-    bool found = false;
-    for (SkRegion::Iterator i(region); !found && !i.done(); i.next()) {
-      found = (i.rect() == r);
+    webrtc::DesktopRect r =
+      webrtc::DesktopRect::MakeXYWH(x * kBlockSize, y * kBlockSize,
+                                    width * kBlockSize, height * kBlockSize);
+    for (webrtc::DesktopRegion::Iterator i(region); !i.IsAtEnd(); i.Advance()) {
+      if (i.rect().equals(r))
+        return true;
     }
-    return found;
+    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);
 
-    SkRegion dirty;
+    webrtc::DesktopRegion dirty;
     MergeBlocks(&dirty);
 
-    bool is_good = dirty.isRect();
-    if (is_good) {
-     is_good = CheckDirtyRegionContainsRect(dirty, x_origin, y_origin,
-                                            width, height);
-    }
-    return is_good;
+
+    webrtc::DesktopRect expected_rect = webrtc::DesktopRect::MakeXYWH(
+        x_origin * kBlockSize, y_origin * kBlockSize,
+        width * kBlockSize, height * kBlockSize);
+
+    // Verify that the region contains expected_rect and it's the only
+    // rectangle.
+    webrtc::DesktopRegion::Iterator it(dirty);
+    return !it.IsAtEnd() && expected_rect.equals(it.rect()) &&
+        (it.Advance(), it.IsAtEnd());
   }
 
   // The differ class we're testing.
   scoped_ptr<Differ> differ_;
 
   // Screen/buffer info.
   int width_;
   int height_;
   int bytes_per_pixel_;
   int stride_;
@@ skipping 177 matching lines @@
   // |   |   |   | _ |
   // +---+---+---+---+
   // |   |   |   | _ |
   // +---+---+---+---+
   // |   |   |   | _ |
   // +---+---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
 
-  SkRegion dirty;
+  webrtc::DesktopRegion dirty;
   MergeBlocks(&dirty);
 
-  EXPECT_TRUE(dirty.isEmpty());
+  EXPECT_TRUE(dirty.is_empty());
 }
 
 TEST_F(DifferTest, MergeBlocks_SingleBlock) {
   InitDiffer(kScreenWidth, kScreenHeight);
   // 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++) {
       ASSERT_TRUE(MarkBlocksAndCheckMerge(x, y, 1, 1)) << "x: " << x
                                                        << "y: " << y;
@@ skipping 132 matching lines @@
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ASSERT_TRUE(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) {
   InitDiffer(kScreenWidth, kScreenHeight);
-  SkRegion dirty;
+  webrtc::DesktopRegion dirty;
 
   // +---+---+---+---+      +---+---+---+
   // |   | X |   | _ |      |   | 0 |   |
   // +---+---+---+---+      +---+---+---+
   // | X |   |   | _ |      | 1 |   |   |
   // +---+---+---+---+  =>  +---+---+---+
   // |   |   | X | _ |      |   |   | 2 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(1, 0, 1, 1);
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 2, 1, 1);
 
-  dirty.setEmpty();
+  dirty.Clear();
   MergeBlocks(&dirty);
 
   ASSERT_EQ(3, RegionRectCount(dirty));
   ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 0, 1, 1));
   ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 1, 1, 1));
   ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 2, 1, 1));
 
   // +---+---+---+---+      +---+---+---+
   // |   |   | X | _ |      |   |   | 0 |
-  // +---+---+---+---+      +---+---+---+
-  // | X | X | X | _ |      | 1   1   1 |
-  // +---+---+---+---+  =>  +           +
-  // | X | X | X | _ |      | 1   1   1 |
+  // +---+---+---+---+      +---+---+   +
+  // | X | X | X | _ |      | 1   1 | 0 |
+  // +---+---+---+---+  =>  +       |   +
+  // | X | X | X | _ |      | 1   1 | 0 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(2, 0, 1, 1);
   MarkBlocks(0, 1, 3, 2);
 
-  dirty.setEmpty();
+  dirty.Clear();
   MergeBlocks(&dirty);
 
   ASSERT_EQ(2, RegionRectCount(dirty));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 0, 1, 1));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 1, 3, 2));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 0, 1, 3));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 1, 2, 2));
 
   // +---+---+---+---+      +---+---+---+
   // |   |   |   | _ |      |   |   |   |
   // +---+---+---+---+      +---+---+---+
   // | X |   | X | _ |      | 0 |   | 1 |
   // +---+---+---+---+  =>  +   +---+   +
-  // | X | X | X | _ |      | 2 | 2 | 2 |
+  // | X | X | X | _ |      | 0 | 2 | 1 |
   // +---+---+---+---+      +---+---+---+
   // | _ | _ | _ | _ |
   // +---+---+---+---+
   ClearDiffInfo();
   MarkBlocks(0, 1, 1, 1);
   MarkBlocks(2, 1, 1, 1);
   MarkBlocks(0, 2, 3, 1);
 
-  dirty.setEmpty();
+  dirty.Clear();
   MergeBlocks(&dirty);
 
   ASSERT_EQ(3, RegionRectCount(dirty));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 1, 1, 1));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 1, 1, 1));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 2, 3, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 1, 1, 2));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 1, 1, 2));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 1, 2, 1, 1));
 
   // +---+---+---+---+      +---+---+---+
   // | X | X | X | _ |      | 0   0   0 |
   // +---+---+---+---+      +---+---+---+
   // | X |   | X | _ |      | 1 |   | 2 |
   // +---+---+---+---+  =>  +   +---+   +
-  // | X | X | X | _ |      | 3 | 3 | 3 |
+  // | 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.setEmpty();
+  dirty.Clear();
   MergeBlocks(&dirty);
 
   ASSERT_EQ(4, RegionRectCount(dirty));
   ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 0, 3, 1));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 1, 1, 1));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 1, 1, 1));
-  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 2, 3, 1));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 0, 1, 1, 2));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 2, 1, 1, 2));
+  ASSERT_TRUE(CheckDirtyRegionContainsRect(dirty, 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.setEmpty();
+  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));
 }
 
 }  // namespace media