Clean up remoting project

remoting/host/capturer_win.cc

Index: remoting/host/capturer_win.cc
diff --git a/remoting/host/capturer_gdi.cc b/remoting/host/capturer_win.cc
similarity index 69%
rename from remoting/host/capturer_gdi.cc
rename to remoting/host/capturer_win.cc
index 8e50bde78e8650c69a3f9fe558033fcd1d536443..e4c45342c07352b429f52a966cbc4d707b1ebea5 100644
--- a/remoting/host/capturer_gdi.cc
+++ b/remoting/host/capturer_win.cc
@@ -2,17 +2,115 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "remoting/host/capturer_gdi.h"
-#include "remoting/host/differ.h"
+#include "remoting/host/capturer.h"
+
+#include <windows.h>
 
+#include "base/memory/scoped_ptr.h"
+#include "remoting/host/capturer_helper.h"
+#include "remoting/host/differ.h"
 #include "ui/gfx/rect.h"
 
 namespace remoting {
 
+namespace {
+
+// CapturerGdi captures 32bit RGB using GDI.
+//
+// CapturerGdi is double-buffered as required by Capturer. See
+// remoting/host/capturer.h.
+class CapturerGdi : public Capturer {
+ public:
+  CapturerGdi();
+  virtual ~CapturerGdi();
+
+  // Capturer interface.
+  virtual void ScreenConfigurationChanged() OVERRIDE;
+  virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
+  virtual void ClearInvalidRects() OVERRIDE;
+  virtual void InvalidateRects(const InvalidRects& inval_rects) OVERRIDE;
+  virtual void InvalidateScreen(const gfx::Size& size) OVERRIDE;
+  virtual void InvalidateFullScreen() OVERRIDE;
+  virtual void CaptureInvalidRects(CaptureCompletedCallback* callback) OVERRIDE;
+  virtual const gfx::Size& size_most_recent() const OVERRIDE;
+
+ private:
+  struct VideoFrameBuffer {
+    VideoFrameBuffer(void* data, const gfx::Size& 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() {
+      data = 0;
+      size = gfx::Size(0, 0);
+      bytes_per_pixel = 0;
+      bytes_per_row = 0;
+    }
+    void* data;
+    gfx::Size size;
+    int bytes_per_pixel;
+    int bytes_per_row;
+  };
+
+  // Make sure that the current buffer has the same size as the screen.
+  void UpdateBufferCapture(const gfx::Size& size);
+
+  // Allocate memory for a buffer of a given size, freeing any memory previously
+  // allocated for that buffer.
+  void ReallocateBuffer(int buffer_index, const gfx::Size& size);
+
+  void CalculateInvalidRects();
+  void CaptureRects(const InvalidRects& rects,
+                    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.
+  gfx::Size GetScreenSize();
+
+  // A thread-safe list of invalid rectangles, and the size of the most
+  // recently captured screen.
+  CapturerHelper helper;
+
+  // There are two buffers for the screen images, as required by Capturer.
+  static const int kNumBuffers = 2;
+  VideoFrameBuffer buffers_[kNumBuffers];
+
+  // Gdi specific information about screen.
+  HDC desktop_dc_;
+  HDC memory_dc_;
+  HBITMAP target_bitmap_[kNumBuffers];
+
+  // The screen size attached to the device contexts through which the screen
+  // is captured.
+  gfx::Size dc_size_;
+
+  // The current buffer with valid data for reading.
+  int current_buffer_;
+
+  // Format of pixels returned in buffer.
+  media::VideoFrame::Format pixel_format_;
+
+  // Class to calculate the difference between two screen bitmaps.
+  scoped_ptr<Differ> differ_;
+
+  // True if we should force a fullscreen capture.
+  bool capture_fullscreen_;
+
+  DISALLOW_COPY_AND_ASSIGN(CapturerGdi);
+};
+
 // 3780 pixels per meter is equivalent to 96 DPI, typical on desktop monitors.

[Jamie, 2011/04/01 10:51:10]

Why can't these be static?

[dmac, 2011/04/01 21:15:07]

I turned them back to static.

-static const int kPixelsPerMeter = 3780;
+const int kPixelsPerMeter = 3780;
 // 32 bit RGBA is 4 bytes per pixel.
-static const int kBytesPerPixel = 4;
+const int kBytesPerPixel = 4;
 
 CapturerGdi::CapturerGdi()
     : desktop_dc_(NULL),
@@ -229,6 +327,8 @@ gfx::Size CapturerGdi::GetScreenSize() {
                    GetSystemMetrics(SM_CYSCREEN));
 }
 
+}  // namespace
+
 // static
 Capturer* Capturer::Create() {
   return new CapturerGdi();