Move code in src/remoting to the new callbacks.

remoting/host/capturer_win.cc

 // Copyright (c) 2011 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 "remoting/host/capturer.h"
 
 #include <windows.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "remoting/host/capturer_helper.h"
@@ skipping 12 matching lines @@
   CapturerGdi();
   virtual ~CapturerGdi();
 
   // Capturer interface.
   virtual void ScreenConfigurationChanged() OVERRIDE;
   virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
   virtual void ClearInvalidRegion() OVERRIDE;
   virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE;
   virtual void InvalidateScreen(const SkISize& size) OVERRIDE;
   virtual void InvalidateFullScreen() OVERRIDE;
-  virtual void CaptureInvalidRegion(CaptureCompletedCallback* callback)
-      OVERRIDE;
+  virtual void CaptureInvalidRegion(
+      const CaptureCompletedCallback& callback) OVERRIDE;
   virtual const SkISize& size_most_recent() const OVERRIDE;
 
  private:
   struct VideoFrameBuffer {
     VideoFrameBuffer(void* data, const SkISize& size, int bytes_per_pixel,
                      int bytes_per_row)
       : data(data), size(size), bytes_per_pixel(bytes_per_pixel),
         bytes_per_row(bytes_per_row) {
     }
     VideoFrameBuffer() {
@@ skipping 10 matching lines @@
 
   // Make sure that the current buffer has the same size as the screen.
   void UpdateBufferCapture(const SkISize& size);
 
   // Allocate memory for a buffer of a given size, freeing any memory previously
   // allocated for that buffer.
   void ReallocateBuffer(int buffer_index, const SkISize& size);
 
   void CalculateInvalidRegion();
   void CaptureRegion(const SkRegion& region,
-                     CaptureCompletedCallback* callback);
+                     const CaptureCompletedCallback& callback);
 
   void ReleaseBuffers();
   // Generates an image in the current buffer.
   void CaptureImage();
 
   // Gets the current screen size and calls ScreenConfigurationChanged
   // if the screen size has changed.
   void MaybeChangeScreenConfiguration();
 
   // Gets the screen size.
@@ skipping 61 matching lines @@
 }
 
 void CapturerGdi::InvalidateScreen(const SkISize& size) {
   helper_.InvalidateScreen(size);
 }
 
 void CapturerGdi::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
 }
 
-void CapturerGdi::CaptureInvalidRegion(CaptureCompletedCallback* callback) {
+void CapturerGdi::CaptureInvalidRegion(
+    const CaptureCompletedCallback& callback) {
   CalculateInvalidRegion();
   SkRegion invalid_region;
   helper_.SwapInvalidRegion(&invalid_region);
   CaptureRegion(invalid_region, callback);
 }
 
 const SkISize& CapturerGdi::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
@@ skipping 112 matching lines @@
       current.bytes_per_pixel, current.bytes_per_row));
   }
 
   SkRegion region;
   differ_->CalcDirtyRegion(prev.data, current.data, &region);
 
   InvalidateRegion(region);
 }
 
 void CapturerGdi::CaptureRegion(const SkRegion& region,
-                                CaptureCompletedCallback* callback) {
-  scoped_ptr<CaptureCompletedCallback> callback_deleter(callback);
-
+                                const CaptureCompletedCallback& callback) {
   const VideoFrameBuffer& buffer = buffers_[current_buffer_];
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
 
   DataPlanes planes;
   planes.data[0] = static_cast<uint8*>(buffer.data);
   planes.strides[0] = buffer.bytes_per_row;
 
   scoped_refptr<CaptureData> data(new CaptureData(planes,
                                                   buffer.size,
                                                   pixel_format_));
   data->mutable_dirty_region() = region;
 
   helper_.set_size_most_recent(data->size());
 
-  callback->Run(data);
+  callback.Run(data);
 }
 
 void CapturerGdi::CaptureImage() {
   // Make sure the structures we use to capture the image have the correct size.
   UpdateBufferCapture(GetScreenSize());
 
   // Select the target bitmap into the memory dc.
   SelectObject(memory_dc_, target_bitmap_[current_buffer_]);
 
   // And then copy the rect from desktop to memory.
   BitBlt(memory_dc_, 0, 0, buffers_[current_buffer_].size.width(),
       buffers_[current_buffer_].size.height(), desktop_dc_, 0, 0,
       SRCCOPY | CAPTUREBLT);
 }
 
 SkISize CapturerGdi::GetScreenSize() {
   return SkISize::Make(GetSystemMetrics(SM_CXSCREEN),
                        GetSystemMetrics(SM_CYSCREEN));
 }
 
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   return new CapturerGdi();
 }
 
 }  // namespace remoting