Cleanup shared memory handling in DesktopCapturer interface.

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 63 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);
+}
+
 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: "
@@ skipping 321 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)) {
-    size_t buffer_size =
-        size.width() * size.height() * DesktopFrame::kBytesPerPixel;
-    SharedMemory* shared_memory = callback_->CreateSharedMemory(buffer_size);
-
-    rtc::scoped_ptr<DesktopFrame> buffer;
-    if (shared_memory) {
-      buffer.reset(new SharedMemoryDesktopFrame(
-          size, size.width() * DesktopFrame::kBytesPerPixel, shared_memory));
-    } else {
-      buffer.reset(new BasicDesktopFrame(size));
-    }
-    queue_.ReplaceCurrentFrame(buffer.release());
+    rtc::scoped_ptr<DesktopFrame> frame =
+        shared_memory_factory_
+            ? SharedMemoryDesktopFrame::Create(size,
+                                               shared_memory_factory_.get())
+            : rtc::scoped_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