Support remoting of all monitors on multi-monitor Windows systems

remoting/host/capturer_win.cc

 // Copyright (c) 2012 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/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_native_library.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_gdi_object.h"
+#include "base/win/scoped_hdc.h"
 #include "remoting/base/capture_data.h"
 #include "remoting/host/capturer_helper.h"
 #include "remoting/host/desktop_win.h"
 #include "remoting/host/differ.h"
 #include "remoting/host/scoped_thread_desktop_win.h"
 #include "remoting/proto/control.pb.h"
 
 namespace remoting {
 
 namespace {
@@ skipping 43 matching lines @@
     VideoFrameBuffer() {
       data = 0;
       size = SkISize::Make(0, 0);
       bytes_per_pixel = 0;
       bytes_per_row = 0;
     }
     void* data;
     SkISize size;
     int bytes_per_pixel;
     int bytes_per_row;
+    int resource_generation;
   };
 
-  // Make sure that the current buffer has the same size as the screen.
-  void UpdateBufferCapture(const SkISize& size);
+  // Make sure that the device contexts and the current bufffer match the screen
+  // configuration.
+  void PrepareCaptureResources();
 
-  // 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);
+  // Allocates the specified capture buffer using the current device contexts
+  // and desktop dimensions, releasing any pre-existing buffer.
+  void AllocateBuffer(int buffer_index);
 
   void CalculateInvalidRegion();
   void CaptureRegion(const SkRegion& region,
                      const CaptureCompletedCallback& callback);
 
-  void ReleaseBuffers();
   // Generates an image in the current buffer.
   void CaptureImage();
 
   // Expand the cursor shape to add a white outline for visibility against
   // dark backgrounds.
   void AddCursorOutline(int width, int height, uint32* dst);
 
   // Capture the current cursor shape.
   void CaptureCursor();
 
-  // Gets the screen size.
-  SkISize GetScreenSize();
-
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   CapturerHelper helper_;
 
   // Callback notified whenever the cursor shape is changed.
   CursorShapeChangedCallback cursor_shape_changed_callback_;
 
   // Snapshot of the last cursor bitmap we sent to the client. This is used
   // to diff against the current cursor so we only send a cursor-change
   // message when the shape has changed.
   scoped_array<uint8> last_cursor_;
   SkISize last_cursor_size_;
 
   // There are two buffers for the screen images, as required by Capturer.
   static const int kNumBuffers = 2;
   VideoFrameBuffer buffers_[kNumBuffers];
 
   ScopedThreadDesktopWin desktop_;
 
-  // Gdi specific information about screen.
-  HWND desktop_window_;
-  HDC desktop_dc_;
-  HDC memory_dc_;
-  HBITMAP target_bitmap_[kNumBuffers];
+  // GDI resources used for screen capture.
+  scoped_ptr<base::win::ScopedGetDC> desktop_dc_;
+  base::win::ScopedCreateDC memory_dc_;
+  base::win::ScopedBitmap target_bitmap_[kNumBuffers];
+  int resource_generation_;
 
-  // The screen size attached to the device contexts through which the screen
-  // is captured.
-  SkISize dc_size_;
+  // Rectangle describing the bounds of the desktop device context.
+  SkIRect desktop_dc_rect_;
 
   // 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_;
 
   base::ScopedNativeLibrary dwmapi_library_;
   DwmEnableCompositionFunc composition_func_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturerGdi);
 };
 
 // 3780 pixels per meter is equivalent to 96 DPI, typical on desktop monitors.
 static const int kPixelsPerMeter = 3780;
 // 32 bit RGBA is 4 bytes per pixel.
 static const int kBytesPerPixel = 4;
 
 CapturerGdi::CapturerGdi()
     : last_cursor_size_(SkISize::Make(0, 0)),
-      desktop_window_(NULL),
-      desktop_dc_(NULL),
-      memory_dc_(NULL),
-      dc_size_(SkISize::Make(0, 0)),
+      desktop_dc_rect_(SkIRect::MakeEmpty()),
+      resource_generation_(0),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32),
       composition_func_(NULL) {
-  memset(target_bitmap_, 0, sizeof(target_bitmap_));
-  memset(buffers_, 0, sizeof(buffers_));
   ScreenConfigurationChanged();
 }
 
 CapturerGdi::~CapturerGdi() {
-  ReleaseBuffers();
 }
 
 media::VideoFrame::Format CapturerGdi::pixel_format() const {
   return pixel_format_;
 }
 
 void CapturerGdi::ClearInvalidRegion() {
   helper_.ClearInvalidRegion();
 }
 
@@ skipping 21 matching lines @@
   CaptureRegion(invalid_region, callback);
 
   // Check for cursor shape update.
   CaptureCursor();
 }
 
 const SkISize& CapturerGdi::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
-void CapturerGdi::ReleaseBuffers() {
-  for (int i = kNumBuffers - 1; i >= 0; i--) {
-    if (target_bitmap_[i]) {
-      DeleteObject(target_bitmap_[i]);
-      target_bitmap_[i] = NULL;
-    }
-    if (buffers_[i].data) {
-      DeleteObject(buffers_[i].data);
-      buffers_[i].data = NULL;
-    }
-  }
-
-  if (desktop_dc_) {
-    ReleaseDC(desktop_window_, desktop_dc_);
-    desktop_window_ = NULL;
-    desktop_dc_ = NULL;
-  }
-
-  if (memory_dc_) {
-    DeleteDC(memory_dc_);
-    memory_dc_ = NULL;
-  }
-}
-
 void CapturerGdi::Start(
     const CursorShapeChangedCallback& callback) {
   cursor_shape_changed_callback_ = callback;
 
   // Load dwmapi.dll dynamically since it is not available on XP.
   if (!dwmapi_library_.is_valid()) {
     FilePath path(base::GetNativeLibraryName(UTF8ToUTF16(kDwmapiLibraryName)));
     dwmapi_library_.Reset(base::LoadNativeLibrary(path, NULL));
   }
 
@@ skipping 14 matching lines @@
   // Restore Aero.
   if (composition_func_ != NULL) {
     (*composition_func_)(DWM_EC_ENABLECOMPOSITION);
   }
 }
 
 void CapturerGdi::ScreenConfigurationChanged() {
   // We poll for screen configuration changes, so ignore notifications.
 }
 
-void CapturerGdi::UpdateBufferCapture(const SkISize& size) {
+void CapturerGdi::PrepareCaptureResources() {
   // Switch to the desktop receiving user input if different from the current
   // one.
   scoped_ptr<DesktopWin> input_desktop = DesktopWin::GetInputDesktop();
   if (input_desktop.get() != NULL && !desktop_.IsSame(*input_desktop)) {
     // Release GDI resources otherwise SetThreadDesktop will fail.
-    if (desktop_dc_) {
-      ReleaseDC(desktop_window_, desktop_dc_);
-      desktop_window_ = NULL;
-      desktop_dc_ = NULL;
-    }
-
-    if (memory_dc_) {
-      DeleteDC(memory_dc_);
-      memory_dc_ = NULL;
-    }
-
-    ReleaseBuffers();
+    desktop_dc_.reset();
+    memory_dc_.Set(NULL);
 
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
-    // So we can continue capture screen bits, just from a diffented desktop.
+    // So we can continue capture screen bits, just from the wrong desktop.
     desktop_.SetThreadDesktop(input_desktop.Pass());
   }
 
-  // Make sure the DCs have the correct dimensions.
-  if (size != dc_size_) {
-    // TODO(simonmorris): screen dimensions changing isn't equivalent to needing
-    // a new DC, but it's good enough for now.
-    if (desktop_dc_) {
-      ReleaseDC(desktop_window_, desktop_dc_);
-      desktop_window_ = NULL;
-      desktop_dc_ = NULL;
-    }
-
-    if (memory_dc_) {
-      DeleteDC(memory_dc_);
-      memory_dc_ = NULL;
-    }
+  // If the display bounds have changed then recreate GDI resources.
+  // TODO(wez): Also check for pixel format changes.
+  SkIRect screen_rect(SkIRect::MakeXYWH(
+      GetSystemMetrics(SM_XVIRTUALSCREEN),
+      GetSystemMetrics(SM_YVIRTUALSCREEN),
+      GetSystemMetrics(SM_CXVIRTUALSCREEN),
+      GetSystemMetrics(SM_CYVIRTUALSCREEN)));
+  if (screen_rect != desktop_dc_rect_) {
+    desktop_dc_.reset();
+    memory_dc_.Set(NULL);
+    desktop_dc_rect_.setEmpty();
   }
 
-  if (desktop_dc_ == NULL) {
-    DCHECK(desktop_window_ == NULL);
-    DCHECK(memory_dc_ == NULL);
+  // Create GDI device contexts to capture from the desktop into memory, and
+  // allocate buffers to capture into.
+  if (desktop_dc_.get() == NULL) {
+    DCHECK(memory_dc_.Get() == NULL);
 
-    desktop_window_ = GetDesktopWindow();
-    desktop_dc_ = GetDC(desktop_window_);
-    memory_dc_ = CreateCompatibleDC(desktop_dc_);
-    dc_size_ = size;
+    desktop_dc_.reset(new base::win::ScopedGetDC(NULL));
+    memory_dc_.Set(CreateCompatibleDC(*desktop_dc_));
+    desktop_dc_rect_ = screen_rect;
+
+    ++resource_generation_;
   }
 
-  // Make sure the current bitmap has the correct dimensions.
-  if (buffers_[current_buffer_].data == NULL ||
-      size != buffers_[current_buffer_].size) {
-    ReallocateBuffer(current_buffer_, 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 (resource_generation_ != buffers_[current_buffer_].resource_generation) {
+    AllocateBuffer(current_buffer_);
     InvalidateFullScreen();
   }
 }
 
-void CapturerGdi::ReallocateBuffer(int buffer_index, const SkISize& size) {
-  // Delete any previously constructed bitmap.
-  if (target_bitmap_[buffer_index]) {
-    DeleteObject(target_bitmap_[buffer_index]);
-    target_bitmap_[buffer_index] = NULL;
-  }
-  if (buffers_[buffer_index].data) {
-    DeleteObject(buffers_[buffer_index].data);
-    buffers_[buffer_index].data = NULL;
-  }
+void CapturerGdi::AllocateBuffer(int buffer_index) {
+  DCHECK(desktop_dc_.get() != NULL);
+  DCHECK(memory_dc_.Get() != NULL);
 
-  // Create a bitmap to keep the desktop image.
-  int rounded_width = (size.width() + 3) & (~3);
+  // Windows requires DIB sections' rows to start DWORD-aligned, which is
+  // implicit when working with RGB32 pixels.
+  DCHECK_EQ(pixel_format_, media::VideoFrame::RGB32);
 
-  // Dimensions of screen.
-  pixel_format_ = media::VideoFrame::RGB32;
-  int bytes_per_row = rounded_width * kBytesPerPixel;
-
-  // Create a device independent bitmap (DIB) that is the same size.
+  // Describe a device independent bitmap (DIB) that is the size of the desktop.
   BITMAPINFO bmi;
   memset(&bmi, 0, sizeof(bmi));
-  bmi.bmiHeader.biHeight = -size.height();
-  bmi.bmiHeader.biWidth = rounded_width;
+  bmi.bmiHeader.biHeight = -desktop_dc_rect_.height();
+  bmi.bmiHeader.biWidth = desktop_dc_rect_.width();
   bmi.bmiHeader.biPlanes = 1;
   bmi.bmiHeader.biBitCount = kBytesPerPixel * 8;
   bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
-  bmi.bmiHeader.biSizeImage = bytes_per_row * size.height();
+  int bytes_per_row = desktop_dc_rect_.width() * kBytesPerPixel;
+  bmi.bmiHeader.biSizeImage = bytes_per_row * desktop_dc_rect_.height();
   bmi.bmiHeader.biXPelsPerMeter = kPixelsPerMeter;
   bmi.bmiHeader.biYPelsPerMeter = kPixelsPerMeter;
 
-  // Create memory for the buffers.
+  // Create the DIB, and store a pointer to its pixel buffer.
   target_bitmap_[buffer_index] =
-      CreateDIBSection(desktop_dc_, &bmi, DIB_RGB_COLORS,
+      CreateDIBSection(*desktop_dc_, &bmi, DIB_RGB_COLORS,
                        static_cast<void**>(&buffers_[buffer_index].data),
                        NULL, 0);
   buffers_[buffer_index].size = SkISize::Make(bmi.bmiHeader.biWidth,
                                               std::abs(bmi.bmiHeader.biHeight));
   buffers_[buffer_index].bytes_per_pixel = bmi.bmiHeader.biBitCount / 8;
   buffers_[buffer_index].bytes_per_row =
       bmi.bmiHeader.biSizeImage / std::abs(bmi.bmiHeader.biHeight);
 }
 
 void CapturerGdi::CalculateInvalidRegion() {
@@ skipping 46 matching lines @@
                                                   buffer.size,
                                                   pixel_format_));
   data->mutable_dirty_region() = region;
 
   helper_.set_size_most_recent(data->size());
 
   callback.Run(data);
 }
 
 void CapturerGdi::CaptureImage() {
-  // Make sure the structures we use to capture the image have the correct size.
-  UpdateBufferCapture(GetScreenSize());
+  // Make sure the GDI capture resources are up-to-date.
+  PrepareCaptureResources();
 
   // 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,
+      buffers_[current_buffer_].size.height(), *desktop_dc_,
+      desktop_dc_rect_.x(), desktop_dc_rect_.y(),
       SRCCOPY | CAPTUREBLT);
 }
 
 void CapturerGdi::AddCursorOutline(int width, int height, uint32* dst) {
   for (int y = 0; y < height; y++) {
     for (int x = 0; x < width; x++) {
       // If this is a transparent pixel (bgr == 0 and alpha = 0), check the
       // neighbor pixels to see if this should be changed to an outline pixel.
       if (*dst == kPixelBgraTransparent) {
         // Change to white pixel if any neighbors (top, bottom, left, right)
@@ skipping 156 matching lines @@
   cursor_proto->set_hotspot_y(hotspot_y);
 
   // Record the last cursor image that we sent to the client.
   last_cursor_.reset(new uint8[data_size]);
   memcpy(last_cursor_.get(), cursor_dst_data, data_size);
   last_cursor_size_ = SkISize::Make(width, height);
 
   cursor_shape_changed_callback_.Run(cursor_proto.Pass());
 }
 
-SkISize CapturerGdi::GetScreenSize() {
-  return SkISize::Make(GetSystemMetrics(SM_CXSCREEN),
-                       GetSystemMetrics(SM_CYSCREEN));
-}
-
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   return new CapturerGdi();
 }
 
 }  // namespace remoting