Replace scoped_ptr with unique_ptr in webrtc/modules/desktop_capture/

webrtc/modules/desktop_capture/win/screen_capturer_win_magnifier.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 20 matching lines @@
 // kMagnifierWindowClass has to be "Magnifier" according to the Magnification
 // API. The other strings can be anything.
 static LPCTSTR kMagnifierHostClass = L"ScreenCapturerWinMagnifierHost";
 static LPCTSTR kHostWindowName = L"MagnifierHost";
 static LPCTSTR kMagnifierWindowClass = L"Magnifier";
 static LPCTSTR kMagnifierWindowName = L"MagnifierWindow";
 
 Atomic32 ScreenCapturerWinMagnifier::tls_index_(TLS_OUT_OF_INDEXES);
 
 ScreenCapturerWinMagnifier::ScreenCapturerWinMagnifier(
-    rtc::scoped_ptr<ScreenCapturer> fallback_capturer)
+    std::unique_ptr<ScreenCapturer> fallback_capturer)
     : fallback_capturer_(std::move(fallback_capturer)),
       fallback_capturer_started_(false),
       callback_(NULL),
       current_screen_id_(kFullDesktopScreenId),
       excluded_window_(NULL),
       set_thread_execution_state_failed_(false),
       desktop_dc_(NULL),
       mag_lib_handle_(NULL),
       mag_initialize_func_(NULL),
       mag_uninitialize_func_(NULL),
@@ skipping 24 matching lines @@
 void ScreenCapturerWinMagnifier::Start(Callback* callback) {
   assert(!callback_);
   assert(callback);
   callback_ = callback;
 
   InitializeMagnifier();
 }
 
 void ScreenCapturerWinMagnifier::SetSharedMemoryFactory(
     rtc::scoped_ptr<SharedMemoryFactory> shared_memory_factory) {
-  shared_memory_factory_ = std::move(shared_memory_factory);
+  shared_memory_factory_ =
+      rtc::ScopedToUnique(std::move(shared_memory_factory));
 }
 
 void ScreenCapturerWinMagnifier::Capture(const DesktopRegion& region) {
   TickTime capture_start_time = TickTime::Now();
 
   queue_.MoveToNextFrame();
 
   // Request that the system not power-down the system, or the display hardware.
   if (!SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED)) {
     if (!set_thread_execution_state_failed_) {
       set_thread_execution_state_failed_ = true;
       LOG_F(LS_WARNING) << "Failed to make system & display power assertion: "
                         << GetLastError();
     }
   }
   // Switch to the desktop receiving user input if different from the current
   // one.
-  rtc::scoped_ptr<Desktop> input_desktop(Desktop::GetInputDesktop());
+  std::unique_ptr<Desktop> input_desktop(Desktop::GetInputDesktop());
   if (input_desktop.get() != NULL && !desktop_.IsSame(*input_desktop)) {
     // Release GDI resources otherwise SetThreadDesktop will fail.
     if (desktop_dc_) {
       ReleaseDC(NULL, desktop_dc_);
       desktop_dc_ = NULL;
     }
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
     // So we can continue capture screen bits, just from the wrong desktop.
     desktop_.SetThreadDesktop(input_desktop.release());
   }
@@ skipping 305 matching lines @@
 
   magnifier_capture_succeeded_ = true;
 }
 
 void ScreenCapturerWinMagnifier::CreateCurrentFrameIfNecessary(
     const DesktopSize& size) {
   // If the current buffer is from an older generation then allocate a new one.
   // Note that we can't reallocate other buffers at this point, since the caller
   // may still be reading from them.
   if (!queue_.current_frame() || !queue_.current_frame()->size().equals(size)) {
-    rtc::scoped_ptr<DesktopFrame> frame =
+    std::unique_ptr<DesktopFrame> frame =
         shared_memory_factory_
             ? SharedMemoryDesktopFrame::Create(size,
                                                shared_memory_factory_.get())
-            : rtc::scoped_ptr<DesktopFrame>(new BasicDesktopFrame(size));
+            : std::unique_ptr<DesktopFrame>(new BasicDesktopFrame(size));
     queue_.ReplaceCurrentFrame(frame.release());
   }
 }
 
 void ScreenCapturerWinMagnifier::StartFallbackCapturer() {
   assert(fallback_capturer_);
   if (!fallback_capturer_started_) {
     fallback_capturer_started_ = true;
 
     fallback_capturer_->Start(callback_);
     fallback_capturer_->SelectScreen(current_screen_id_);
   }
 }
 
 }  // namespace webrtc