Clean up remoting project

remoting/host/capturer_linux.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_linux.h"
+#include "remoting/host/capturer.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 
 #include <set>
 
+#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "remoting/base/types.h"
 #include "remoting/host/capturer_helper.h"
 #include "remoting/host/x_server_pixel_buffer.h"
 
 namespace remoting {
 
-// Private Implementation pattern to avoid leaking the X11 types into the header
-// file.
-class CapturerLinuxPimpl : public Capturer {
+namespace {
+
+// A class to perform capturing for Linux.
+class CapturerLinux : public Capturer {
  public:
-  CapturerLinuxPimpl();
-  virtual ~CapturerLinuxPimpl();
+  CapturerLinux();
+  virtual ~CapturerLinux();
 
-  bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
 
   // Capturer interface.
-  virtual void ScreenConfigurationChanged();
-  virtual media::VideoFrame::Format pixel_format() const;
-  virtual void ClearInvalidRects();
-  virtual void InvalidateRects(const InvalidRects& inval_rects);
-  virtual void InvalidateScreen(const gfx::Size& size);
-  virtual void InvalidateFullScreen();
-  virtual void CaptureInvalidRects(CaptureCompletedCallback* callback);
-  virtual const gfx::Size& size_most_recent() const;
+  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:
+  bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
   void CalculateInvalidRects();
   void CaptureRects(const InvalidRects& rects,
                     Capturer::CaptureCompletedCallback* callback);
 
   void DeinitXlib();
   // We expose two forms of blitting to handle variations in the pixel format.
   // In FastBlit, the operation is effectively a memcpy.
   void FastBlit(uint8* image, const gfx::Rect& rect, CaptureData* capture_data);
   void SlowBlit(uint8* image, const gfx::Rect& rect, CaptureData* capture_data);
 
@@ skipping 27 matching lines @@
 
   // Format of pixels returned in buffer.
   media::VideoFrame::Format pixel_format_;
 
   // Invalid rects in the last capture. This is used to synchronize current with
   // the previous buffer used.
   InvalidRects last_invalid_rects_;
 
   // Last capture buffer used.
   uint8* last_buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(CapturerLinux);
 };
 
 CapturerLinux::CapturerLinux()
-    : pimpl_(new CapturerLinuxPimpl()) {
-  // TODO(ajwong): This should be moved into an Init() method on Capturer
-  // itself.  Then we can remove the CHECK.
-  CHECK(pimpl_->Init());
-}
-
-CapturerLinux::~CapturerLinux() {
-}
-
-void CapturerLinux::ScreenConfigurationChanged() {
-  pimpl_->ScreenConfigurationChanged();
-}
-
-media::VideoFrame::Format CapturerLinux::pixel_format() const {
-  return pimpl_->pixel_format();
-}
-
-void CapturerLinux::ClearInvalidRects() {
-  pimpl_->ClearInvalidRects();
-}
-
-void CapturerLinux::InvalidateRects(const InvalidRects& inval_rects) {
-  pimpl_->InvalidateRects(inval_rects);
-}
-
-void CapturerLinux::InvalidateScreen(const gfx::Size& size) {
-  pimpl_->InvalidateScreen(size);
-}
-
-void CapturerLinux::InvalidateFullScreen() {
-  pimpl_->InvalidateFullScreen();
-}
-
-void CapturerLinux::CaptureInvalidRects(CaptureCompletedCallback* callback) {
-  pimpl_->CaptureInvalidRects(callback);
-}
-
-const gfx::Size& CapturerLinux::size_most_recent() const {
-  return pimpl_->size_most_recent();
-}
-
-CapturerLinuxPimpl::CapturerLinuxPimpl()
     : display_(NULL),
       gc_(NULL),
       root_window_(BadValue),
       width_(0),
       height_(0),
       damage_handle_(BadValue),
       damage_event_base_(-1),
       damage_error_base_(-1),
       current_buffer_(0),
       stride_(0),
       capture_fullscreen_(true),
       pixel_format_(media::VideoFrame::RGB32),
       last_buffer_(NULL) {
   for (int i = 0; i < kNumBuffers; i++) {
     buffers_[i] = NULL;
   }
+  CHECK(Init());
 }
 
-CapturerLinuxPimpl::~CapturerLinuxPimpl() {
+CapturerLinux::~CapturerLinux() {
   DeinitXlib();
 
   for (int i = 0; i < kNumBuffers; i++) {
     delete [] buffers_[i];
     buffers_[i] = NULL;
   }
 }
 
-bool CapturerLinuxPimpl::Init() {
+bool CapturerLinux::Init() {
   // TODO(ajwong): We should specify the display string we are attaching to
   // in the constructor.
   display_ = XOpenDisplay(NULL);
   if (!display_) {
     LOG(ERROR) << "Unable to open display";
     return false;
   }
 
   x_server_pixel_buffer_.Init(display_);
 
@@ skipping 39 matching lines @@
   VLOG(1) << "Initialized with Geometry: " << width_ << "x" << height_;
 
   // Allocate the screen buffers.
   for (int i = 0; i < kNumBuffers; i++) {
     buffers_[i] = new uint8[width_ * height_ * kBytesPerPixel];
   }
 
   return true;
 }
 
-void CapturerLinuxPimpl::ScreenConfigurationChanged() {
+void CapturerLinux::ScreenConfigurationChanged() {
   // TODO(ajwong): Support resolution changes.
   NOTIMPLEMENTED();
 }
 
-media::VideoFrame::Format CapturerLinuxPimpl::pixel_format() const {
+media::VideoFrame::Format CapturerLinux::pixel_format() const {
   return pixel_format_;
 }
 
-void CapturerLinuxPimpl::ClearInvalidRects() {
+void CapturerLinux::ClearInvalidRects() {
   helper_.ClearInvalidRects();
 }
 
-void CapturerLinuxPimpl::InvalidateRects(const InvalidRects& inval_rects) {
+void CapturerLinux::InvalidateRects(const InvalidRects& inval_rects) {
   helper_.InvalidateRects(inval_rects);
 }
 
-void CapturerLinuxPimpl::InvalidateScreen(const gfx::Size& size) {
+void CapturerLinux::InvalidateScreen(const gfx::Size& size) {
   helper_.InvalidateScreen(size);
 }
 
-void CapturerLinuxPimpl::InvalidateFullScreen() {
+void CapturerLinux::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
 }
 
-void CapturerLinuxPimpl::CaptureInvalidRects(
+void CapturerLinux::CaptureInvalidRects(
     CaptureCompletedCallback* callback) {
   CalculateInvalidRects();
 
   InvalidRects rects;
   helper_.SwapInvalidRects(rects);
 
   CaptureRects(rects, callback);
 }
 
-void CapturerLinuxPimpl::CalculateInvalidRects() {
+void CapturerLinux::CalculateInvalidRects() {
   if (helper_.IsCaptureFullScreen(gfx::Size(width_, height_)))
     capture_fullscreen_ = true;
 
   // TODO(ajwong): The capture_fullscreen_ logic here is very ugly. Refactor.
 
   // Find the number of events that are outstanding "now."  We don't just loop
   // on XPending because we want to guarantee this terminates.
   int events_to_process = XPending(display_);
   XEvent e;
   InvalidRects invalid_rects;
@@ skipping 22 matching lines @@
 
   if (capture_fullscreen_) {
     // TODO(hclam): Check the new dimension again.
     helper_.InvalidateScreen(gfx::Size(width_, height_));
     capture_fullscreen_ = false;
   } else {
     helper_.InvalidateRects(invalid_rects);
   }
 }
 
-void CapturerLinuxPimpl::CaptureRects(
+void CapturerLinux::CaptureRects(
     const InvalidRects& rects,
     Capturer::CaptureCompletedCallback* callback) {
   scoped_ptr<CaptureCompletedCallback> callback_deleter(callback);
 
   uint8* buffer = buffers_[current_buffer_];
   DataPlanes planes;
   planes.data[0] = buffer;
   planes.strides[0] = stride_;
 
   scoped_refptr<CaptureData> capture_data(new CaptureData(
@@ skipping 39 matching lines @@
   capture_data->mutable_dirty_rects() = rects;
   last_invalid_rects_ = rects;
   last_buffer_ = buffer;
 
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
   helper_.set_size_most_recent(capture_data->size());
 
   callback->Run(capture_data);
 }
 
-void CapturerLinuxPimpl::DeinitXlib() {
+void CapturerLinux::DeinitXlib() {
   if (gc_) {
     XFreeGC(display_, gc_);
     gc_ = NULL;
   }
 
   if (display_) {
     XCloseDisplay(display_);
     display_ = NULL;
   }
 }
 
-void CapturerLinuxPimpl::FastBlit(uint8* image, const gfx::Rect& rect,
+void CapturerLinux::FastBlit(uint8* image, const gfx::Rect& rect,
                                   CaptureData* capture_data) {
   uint8* src_pos = image;
   int src_stride = x_server_pixel_buffer_.GetStride();
   int dst_x = rect.x(), dst_y = rect.y();
 
   DataPlanes planes = capture_data->data_planes();
   uint8* dst_buffer = planes.data[0];
 
   const int dst_stride = planes.strides[0];
 
   uint8* dst_pos = dst_buffer + dst_stride * dst_y;
   dst_pos += dst_x * kBytesPerPixel;
 
   int height = rect.height(), row_bytes = rect.width() * kBytesPerPixel;
   for (int y = 0; y < height; ++y) {
     memcpy(dst_pos, src_pos, row_bytes);
     src_pos += src_stride;
     dst_pos += dst_stride;
   }
 }
 
-void CapturerLinuxPimpl::SlowBlit(uint8* image, const gfx::Rect& rect,
+void CapturerLinux::SlowBlit(uint8* image, const gfx::Rect& rect,
                                   CaptureData* capture_data) {
   DataPlanes planes = capture_data->data_planes();
   uint8* dst_buffer = planes.data[0];
   const int dst_stride = planes.strides[0];
   int src_stride = x_server_pixel_buffer_.GetStride();
   int dst_x = rect.x(), dst_y = rect.y();
   int width = rect.width(), height = rect.height();
 
   unsigned int red_mask = x_server_pixel_buffer_.GetRedMask();
   unsigned int blue_mask = x_server_pixel_buffer_.GetBlueMask();
@@ skipping 30 matching lines @@
       uint32_t b = (((pixel & blue_mask) >> blue_shift) * 255) / max_blue;
       uint32_t g = (((pixel & green_mask) >> green_shift) * 255) / max_green;
       // Write as 32-bit RGB.
       dst_pos_32[x] = r << 16 | g << 8 | b;
     }
     dst_pos += dst_stride;
     src_pos += src_stride;
   }
 }
 
-const gfx::Size& CapturerLinuxPimpl::size_most_recent() const {
+const gfx::Size& CapturerLinux::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
+}  // namespace
+
 // static
 Capturer* Capturer::Create() {
   return new CapturerLinux();
 }
 
 }  // namespace remoting