Use webrtc::DesktopCapturer for screen capturer implementation.

media/video/capture/screen/screen_capturer_unittest.cc

Index: media/video/capture/screen/screen_capturer_unittest.cc
diff --git a/media/video/capture/screen/screen_capturer_unittest.cc b/media/video/capture/screen/screen_capturer_unittest.cc
index 4ed45d9648cc45be2b262f56a0ae42a9fac5393c..87074786f6b3392a8a0ed7edbc77d96b3315ab4b 100644
--- a/media/video/capture/screen/screen_capturer_unittest.cc
+++ b/media/video/capture/screen/screen_capturer_unittest.cc
@@ -8,10 +8,11 @@
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif  // defined(OS_MACOSX)
-#include "media/video/capture/screen/screen_capture_data.h"
 #include "media/video/capture/screen/screen_capturer_mock_objects.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
@@ -20,65 +21,58 @@ using ::testing::Return;
 namespace media {
 
 MATCHER(DirtyRegionIsNonEmptyRect, "") {
-  const SkRegion& dirty_region = arg->dirty_region();
-  const SkIRect& dirty_region_bounds = dirty_region.getBounds();
-  if (dirty_region_bounds.isEmpty()) {
-    return false;
-  }
-  return dirty_region == SkRegion(dirty_region_bounds);
+  const webrtc::DesktopRegion& updated_region = arg->updated_region();
+  webrtc::DesktopRegion::Iterator it(updated_region);
+  return !it.IsAtEnd() && (it.Advance(), it.IsAtEnd());

[alexeypa (please no reviews), 2013/05/08 22:24:59]

The name of the matcher does not reflect what it does. How about
IsUpdatedRegionComplex()?

Please comment what |&& (it.Advance(), it.IsAtEnd())| do because it is not
obvious (and different from before).

[Sergey Ulanov, 2013/05/09 18:49:02]

I think it's correct. This matcher verifies that the region is _not_ complex,
i.e. that it consists of a single rectangle.
No, it's not different.

 }
 
 class ScreenCapturerTest : public testing::Test {
  public:
-  scoped_refptr<SharedBuffer> CreateSharedBuffer(uint32 size);
 
  protected:
   scoped_ptr<ScreenCapturer> capturer_;
-  MockScreenCapturerDelegate delegate_;
+  MockMouseShapeObserver mouse_observer_;
+  MockScreenCapturerCallback callback_;
 };
 
-scoped_refptr<SharedBuffer> ScreenCapturerTest::CreateSharedBuffer(
-    uint32 size) {
-  return scoped_refptr<SharedBuffer>(new SharedBuffer(size));
-}
-
 TEST_F(ScreenCapturerTest, StartCapturer) {
   capturer_ = ScreenCapturer::Create();
-  capturer_->Start(&delegate_);
+  capturer_->SetMouseShapeObserver(&mouse_observer_);
+  capturer_->Start(&callback_);
 }
 
 TEST_F(ScreenCapturerTest, Capture) {
   // Assume that Start() treats the screen as invalid initially.
-  EXPECT_CALL(delegate_,
+  EXPECT_CALL(callback_,
               OnCaptureCompleted(DirtyRegionIsNonEmptyRect()));
-  EXPECT_CALL(delegate_, OnCursorShapeChangedPtr(_))
+  EXPECT_CALL(mouse_observer_, OnCursorShapeChangedPtr(_))
       .Times(AnyNumber());
 
-  EXPECT_CALL(delegate_, CreateSharedBuffer(_))
+  EXPECT_CALL(callback_, CreateSharedMemory(_))
       .Times(AnyNumber())
-      .WillRepeatedly(Return(scoped_refptr<SharedBuffer>()));
+      .WillRepeatedly(Return(static_cast<webrtc::SharedMemory*>(NULL)));
 
   capturer_ = ScreenCapturer::Create();
-  capturer_->Start(&delegate_);
-  capturer_->CaptureFrame();
+  capturer_->Start(&callback_);
+  capturer_->Capture(webrtc::DesktopRegion());
 }
 
 #if defined(OS_WIN)
 
 TEST_F(ScreenCapturerTest, UseSharedBuffers) {
-  EXPECT_CALL(delegate_,
+  EXPECT_CALL(callback_,
               OnCaptureCompleted(DirtyRegionIsNonEmptyRect()));
-  EXPECT_CALL(delegate_, OnCursorShapeChangedPtr(_))
+  EXPECT_CALL(mouse_observer_, OnCursorShapeChangedPtr(_))
       .Times(AnyNumber());
 
-  EXPECT_CALL(delegate_, CreateSharedBuffer(_))
+  EXPECT_CALL(callback_, CreateSharedBuffer(_))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(this, &ScreenCapturerTest::CreateSharedBuffer));
-  EXPECT_CALL(delegate_, ReleaseSharedBuffer(_))
+  EXPECT_CALL(callback_, ReleaseSharedBuffer(_))
       .Times(AnyNumber());
 
   capturer_ = ScreenCapturer::Create();
-  capturer_->Start(&delegate_);
+  capturer_->Start(&callback_);
   capturer_->CaptureFrame();
   capturer_.reset();
 }