Replace scoped_ptr with unique_ptr in webrtc/modules/desktop_capture/

webrtc/modules/desktop_capture/desktop_and_cursor_composer_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 "webrtc/modules/desktop_capture/desktop_and_cursor_composer.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
 #include "webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "webrtc/modules/desktop_capture/shared_desktop_frame.h"
 #include "webrtc/modules/desktop_capture/window_capturer.h"
 #include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 
 namespace {
@@ skipping 55 matching lines @@
     callback_->OnCaptureCompleted(next_frame_.release());
   }
 
   void SetNextFrame(DesktopFrame* next_frame) {
     next_frame_.reset(next_frame);
   }
 
  private:
   Callback* callback_;
 
-  rtc::scoped_ptr<DesktopFrame> next_frame_;
+  std::unique_ptr<DesktopFrame> next_frame_;
 };
 
 class FakeMouseMonitor : public MouseCursorMonitor {
  public:
   FakeMouseMonitor() : changed_(true) {}
 
   void SetState(CursorState state, const DesktopVector& pos) {
     state_ = state;
     position_ = pos;
   }
 
   void SetHotspot(const DesktopVector& hotspot) {
     if (!hotspot_.equals(hotspot))
       changed_ = true;
     hotspot_ = hotspot;
   }
 
   void Init(Callback* callback, Mode mode) override { callback_ = callback; }
 
   void Capture() override {
     if (changed_) {
-      rtc::scoped_ptr<DesktopFrame> image(
+      std::unique_ptr<DesktopFrame> image(
           new BasicDesktopFrame(DesktopSize(kCursorWidth, kCursorHeight)));
       uint32_t* data = reinterpret_cast<uint32_t*>(image->data());
       memset(data, 0, image->stride() * kCursorHeight);
 
       // Set four pixels near the hotspot and leave all other blank.
       for (int y = 0; y < kTestCursorSize; ++y) {
         for (int x = 0; x < kTestCursorSize; ++x) {
           data[(hotspot_.y() + y) * kCursorWidth + (hotspot_.x() + x)] =
               kTestCursorData[y][x];
         }
@@ skipping 46 matching lines @@
 
   // DesktopCapturer::Callback interface
   void OnCaptureCompleted(DesktopFrame* frame) override { frame_.reset(frame); }
 
  protected:
   // Owned by |blender_|.
   FakeScreenCapturer* fake_screen_;
   FakeMouseMonitor* fake_cursor_;
 
   DesktopAndCursorComposer blender_;
-  rtc::scoped_ptr<DesktopFrame> frame_;
+  std::unique_ptr<DesktopFrame> frame_;
 };
 
 // Verify DesktopAndCursorComposer can handle the case when the screen capturer
 // fails.
 TEST_F(DesktopAndCursorComposerTest, Error) {
   blender_.Start(this);
 
   fake_cursor_->SetHotspot(DesktopVector());
   fake_cursor_->SetState(MouseCursorMonitor::INSIDE, DesktopVector());
   fake_screen_->SetNextFrame(NULL);
 
   blender_.Capture(DesktopRegion());
 
-  EXPECT_EQ(frame_, static_cast<DesktopFrame*>(NULL));
+  EXPECT_FALSE(frame_);
 }
 
 TEST_F(DesktopAndCursorComposerTest, Blend) {
   struct {
     int x, y;
     int hotspot_x, hotspot_y;
     bool inside;
   } tests[] = {
     {0, 0, 0, 0, true},
     {50, 50, 0, 0, true},
@@ skipping 17 matching lines @@
 
     DesktopVector hotspot(tests[i].hotspot_x, tests[i].hotspot_y);
     fake_cursor_->SetHotspot(hotspot);
 
     MouseCursorMonitor::CursorState state = tests[i].inside
                                                 ? MouseCursorMonitor::INSIDE
                                                 : MouseCursorMonitor::OUTSIDE;
     DesktopVector pos(tests[i].x, tests[i].y);
     fake_cursor_->SetState(state, pos);
 
-    rtc::scoped_ptr<SharedDesktopFrame> frame(
+    std::unique_ptr<SharedDesktopFrame> frame(
         SharedDesktopFrame::Wrap(CreateTestFrame()));
     fake_screen_->SetNextFrame(frame->Share());
 
     blender_.Capture(DesktopRegion());
 
     VerifyFrame(*frame_, state, pos);
 
     // Verify that the cursor is erased before the frame buffer is returned to
     // the screen capturer.
     frame_.reset();
     VerifyFrame(*frame, MouseCursorMonitor::OUTSIDE, DesktopVector());
   }
 }
 
 }  // namespace
 
 }  // namespace webrtc