Update webrtc::DesktopCapturer clients to implement OnCaptureResult().

content/browser/media/capture/desktop_capture_device_unittest.cc

 // Copyright (c) 2013 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 "content/browser/media/capture/desktop_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <algorithm>
@@ skipping 93 matching lines @@
                 storage == media::PIXEL_STORAGE_CPU);
     DoResurrectLastOutputBuffer();
     return std::unique_ptr<Buffer>();
   }
   double GetBufferPoolUtilization() const override { return 0.0; }
 };
 
 // Creates a DesktopFrame that has the first pixel bytes set to
 // kFakePixelValueFirst, and the rest of the bytes set to kFakePixelValue, for
 // UnpackedFrame and InvertedFrame verification.
-webrtc::BasicDesktopFrame* CreateBasicFrame(const webrtc::DesktopSize& size) {
-  webrtc::BasicDesktopFrame* frame = new webrtc::BasicDesktopFrame(size);
+std::unique_ptr<webrtc::BasicDesktopFrame> CreateBasicFrame(
+    const webrtc::DesktopSize& size) {
+  std::unique_ptr<webrtc::BasicDesktopFrame> frame(
+      new webrtc::BasicDesktopFrame(size));
   DCHECK_EQ(frame->size().width() * webrtc::DesktopFrame::kBytesPerPixel,
             frame->stride());
-  memset(frame->data(),
-         kFakePixelValue,
+  memset(frame->data(), kFakePixelValue,
          frame->stride() * frame->size().height());
-  memset(frame->data(),
-         kFakePixelValueFirst,
+  memset(frame->data(), kFakePixelValueFirst,
          webrtc::DesktopFrame::kBytesPerPixel);
   return frame;
 }
 
 // DesktopFrame wrapper that flips wrapped frame upside down by inverting
 // stride.
 class InvertedDesktopFrame : public webrtc::DesktopFrame {
  public:
   // Takes ownership of |frame|.
-  explicit InvertedDesktopFrame(webrtc::DesktopFrame* frame)
+  explicit InvertedDesktopFrame(std::unique_ptr<webrtc::DesktopFrame> frame)
       : webrtc::DesktopFrame(
             frame->size(),
             -frame->stride(),
             frame->data() + (frame->size().height() - 1) * frame->stride(),
-            frame->shared_memory()),
-        original_frame_(frame) {
+            frame->shared_memory()) {
     set_dpi(frame->dpi());
     set_capture_time_ms(frame->capture_time_ms());
     mutable_updated_region()->Swap(frame->mutable_updated_region());
+    original_frame_ = std::move(frame);
   }
   ~InvertedDesktopFrame() override {}
 
  private:
   std::unique_ptr<webrtc::DesktopFrame> original_frame_;
 
   DISALLOW_COPY_AND_ASSIGN(InvertedDesktopFrame);
 };
 
 // DesktopFrame wrapper that copies the input frame and doubles the stride.
 class UnpackedDesktopFrame : public webrtc::DesktopFrame {
  public:
   // Takes ownership of |frame|.
-  explicit UnpackedDesktopFrame(webrtc::DesktopFrame* frame)
+  explicit UnpackedDesktopFrame(std::unique_ptr<webrtc::DesktopFrame> frame)
       : webrtc::DesktopFrame(
             frame->size(),
             frame->stride() * 2,
             new uint8_t[frame->stride() * 2 * frame->size().height()],
-            NULL) {
+            nullptr) {
     memset(data(), kFramePaddingValue, stride() * size().height());
-    CopyPixelsFrom(*frame,
-                   webrtc::DesktopVector(),
+    CopyPixelsFrom(*frame, webrtc::DesktopVector(),
                    webrtc::DesktopRect::MakeSize(size()));
-    delete frame;
   }
   ~UnpackedDesktopFrame() override {
     delete[] data_;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnpackedDesktopFrame);
 };
 
 // TODO(sergeyu): Move this to a separate file where it can be reused.
@@ skipping 20 matching lines @@
 
   void Capture(const webrtc::DesktopRegion& region) override {
     webrtc::DesktopSize size;
     if (frame_index_ % 2 == 0) {
       size = webrtc::DesktopSize(kTestFrameWidth1, kTestFrameHeight1);
     } else {
       size = webrtc::DesktopSize(kTestFrameWidth2, kTestFrameHeight2);
     }
     frame_index_++;
 
-    webrtc::DesktopFrame* frame = CreateBasicFrame(size);
+    std::unique_ptr<webrtc::DesktopFrame> frame = CreateBasicFrame(size);
 
     if (generate_inverted_frames_) {
-      frame = new InvertedDesktopFrame(frame);
+      frame.reset(new InvertedDesktopFrame(std::move(frame)));
     } else if (generate_cropped_frames_) {
-      frame = new UnpackedDesktopFrame(frame);
+      frame.reset(new UnpackedDesktopFrame(std::move(frame)));
     }
-    callback_->OnCaptureCompleted(frame);
+    callback_->OnCaptureResult(webrtc::DesktopCapturer::Result::SUCCESS,
+                               std::move(frame));
   }
 
   bool GetScreenList(ScreenList* screens) override { return false; }
 
   bool SelectScreen(webrtc::ScreenId id) override { return false; }
 
  private:
   Callback* callback_;
   int frame_index_;
   bool generate_inverted_frames_;
@@ skipping 267 matching lines @@
       media::PIXEL_FORMAT_I420;
 
   capture_device_->AllocateAndStart(capture_params, std::move(client));
 
   EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
   done_event.Reset();
   capture_device_->StopAndDeAllocate();
 
   // Verifies that |output_frame_| has the same data as a packed frame of the
   // same size.
-  std::unique_ptr<webrtc::BasicDesktopFrame> expected_frame(CreateBasicFrame(
-      webrtc::DesktopSize(kTestFrameWidth1, kTestFrameHeight1)));
+  std::unique_ptr<webrtc::BasicDesktopFrame> expected_frame = CreateBasicFrame(
+      webrtc::DesktopSize(kTestFrameWidth1, kTestFrameHeight1));
   EXPECT_EQ(output_frame_->stride() * output_frame_->size().height(),
             frame_size);
   EXPECT_EQ(
       0, memcmp(output_frame_->data(), expected_frame->data(), frame_size));
 }
 
 // The test verifies that a bottom-to-top frame is converted to top-to-bottom.
 TEST_F(DesktopCaptureDeviceTest, InvertedFrame) {
   FakeScreenCapturer* mock_capturer = new FakeScreenCapturer();
   mock_capturer->set_generate_inverted_frames(true);
@@ skipping 38 matching lines @@
             frame_size);
   for (int i = 0; i < output_frame_->size().height(); ++i) {
     EXPECT_EQ(0,
         memcmp(inverted_frame->data() + i * inverted_frame->stride(),
                output_frame_->data() + i * output_frame_->stride(),
                output_frame_->stride()));
   }
 }
 
 }  // namespace content