Modify ScreenCaptureFrameQueue into a template

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 72 matching lines @@
 
 void ScreenCapturerWinMagnifier::SetSharedMemoryFactory(
     rtc::scoped_ptr<SharedMemoryFactory> 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();
+  queue_.MoveToNext();
 
   // 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
@@ skipping 24 matching lines @@
   }
 
   // Defer to the fallback capturer if magnifier capturer did not work.
   if (!succeeded) {
     LOG_F(LS_WARNING) << "Switching to the fallback screen capturer.";
     StartFallbackCapturer();
     fallback_capturer_->Capture(region);
     return;
   }
 
-  const DesktopFrame* current_frame = queue_.current_frame();
-  const DesktopFrame* last_frame = queue_.previous_frame();
+  const DesktopFrame* current_frame = queue_.current();
+  const DesktopFrame* last_frame = queue_.previous();
   if (last_frame && last_frame->size().equals(current_frame->size())) {
     // Make sure the differencer is set up correctly for these previous and
     // current screens.
     if (!differ_.get() || (differ_->width() != current_frame->size().width()) ||
         (differ_->height() != current_frame->size().height()) ||
         (differ_->bytes_per_row() != current_frame->stride())) {
       differ_.reset(new Differ(current_frame->size().width(),
                                current_frame->size().height(),
                                DesktopFrame::kBytesPerPixel,
                                current_frame->stride()));
     }
 
     // Calculate difference between the two last captured frames.
     DesktopRegion region;
     differ_->CalcDirtyRegion(
         last_frame->data(), current_frame->data(), &region);
     helper_.InvalidateRegion(region);
   } else {
     // No previous frame is available, or the screen is resized. Invalidate the
     // whole screen.
     helper_.InvalidateScreen(current_frame->size());
   }
 
   helper_.set_size_most_recent(current_frame->size());
 
   // Emit the current frame.
-  DesktopFrame* frame = queue_.current_frame()->Share();
+  DesktopFrame* frame = queue_.current()->Share();
   frame->set_dpi(DesktopVector(GetDeviceCaps(desktop_dc_, LOGPIXELSX),
                                GetDeviceCaps(desktop_dc_, LOGPIXELSY)));
   frame->mutable_updated_region()->Clear();
   helper_.TakeInvalidRegion(frame->mutable_updated_region());
   frame->set_capture_time_ms(
       (TickTime::Now() - capture_start_time).Milliseconds());
   callback_->OnCaptureCompleted(frame);
 }
 
 bool ScreenCapturerWinMagnifier::GetScreenList(ScreenList* screens) {
@@ skipping 209 matching lines @@
 
   assert(tls_index_.Value() != static_cast<int32_t>(TLS_OUT_OF_INDEXES));
   TlsSetValue(tls_index_.Value(), this);
 
   magnifier_initialized_ = true;
   return true;
 }
 
 void ScreenCapturerWinMagnifier::OnCaptured(void* data,
                                             const MAGIMAGEHEADER& header) {
-  DesktopFrame* current_frame = queue_.current_frame();
+  DesktopFrame* current_frame = queue_.current();
 
   // Verify the format.
   // TODO(jiayl): support capturing sources with pixel formats other than RGBA.
   int captured_bytes_per_pixel = header.cbSize / header.width / header.height;
   if (header.format != GUID_WICPixelFormat32bppRGBA ||
       header.width != static_cast<UINT>(current_frame->size().width()) ||
       header.height != static_cast<UINT>(current_frame->size().height()) ||
       header.stride != static_cast<UINT>(current_frame->stride()) ||
       captured_bytes_per_pixel != DesktopFrame::kBytesPerPixel) {
     LOG_F(LS_WARNING) << "Output format does not match the captured format: "
@@ skipping 13 matching lines @@
       DesktopRect::MakeXYWH(0, 0, header.width, header.height));
 
   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)) {
+  if (!queue_.current() || !queue_.current()->size().equals(size)) {
     std::unique_ptr<DesktopFrame> frame =
         shared_memory_factory_
             ? SharedMemoryDesktopFrame::Create(size,
                                                shared_memory_factory_.get())
             : std::unique_ptr<DesktopFrame>(new BasicDesktopFrame(size));
-    queue_.ReplaceCurrentFrame(frame.release());
+    queue_.ReplaceCurrent(SharedDesktopFrame::Wrap(std::move(frame)));
   }
 }
 
 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