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"
@@ skipping 70 matching lines @@
   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,
                      const CaptureCompletedCallback& callback);
 
-  void ReleaseBuffers();
+  // Release all GDI resources, including bitmaps and device contexts.
+  void ReleaseGdiResources();
+
   // 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();
 
@@ skipping 12 matching lines @@
   // 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_;
+  // GDI resources used for screen capture.
   HDC desktop_dc_;

[alexeypa (please no reviews), 2012/07/02 15:50:11]

nit: There are ScopedGetDC and ScopedCreateDC available.

[Wez, 2012/07/03 20:56:26]

Done.

   HDC memory_dc_;
   HBITMAP target_bitmap_[kNumBuffers];

[alexeypa (please no reviews), 2012/07/02 15:50:11]

nit: ScopedBitmap can be used here.

[Wez, 2012/07/03 20:56:26]

Done.

 
   // The screen size attached to the device contexts through which the screen
   // is captured.
   SkISize 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_;
 
   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)),
       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();
+  ReleaseGdiResources();
 }
 
 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() {
+void CapturerGdi::ReleaseGdiResources() {
   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;
+    ReleaseDC(NULL, desktop_dc_);
     desktop_dc_ = NULL;
   }
 
   if (memory_dc_) {
     DeleteDC(memory_dc_);
     memory_dc_ = NULL;
   }
 }
 
 void CapturerGdi::Start(
@@ skipping 29 matching lines @@
 void CapturerGdi::ScreenConfigurationChanged() {
   // We poll for screen configuration changes, so ignore notifications.
 }
 
 void CapturerGdi::UpdateBufferCapture(const SkISize& size) {
   // 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();
+    ReleaseGdiResources();
 
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
     // So we can continue capture screen bits, just from a diffented desktop.
     desktop_.SetThreadDesktop(input_desktop.Pass());
   }
 
-  // Make sure the DCs have the correct dimensions.
+  // If the display dimensions have changed then recreate GDI resources.
   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;
-    }
+    ReleaseGdiResources();
   }
 
+  // Create GDI device contexts to capture from the desktop into memory.
   if (desktop_dc_ == NULL) {
-    DCHECK(desktop_window_ == NULL);
     DCHECK(memory_dc_ == NULL);
+    DCHECK(target_bitmap_[0] == NULL);
+    DCHECK(buffers_[0].data == NULL);
 
-    desktop_window_ = GetDesktopWindow();
-    desktop_dc_ = GetDC(desktop_window_);
+    desktop_dc_ = GetDC(NULL);
     memory_dc_ = CreateCompatibleDC(desktop_dc_);
     dc_size_ = size;
   }
 
   // Make sure the current bitmap has the correct dimensions.
   if (buffers_[current_buffer_].data == NULL ||
       size != buffers_[current_buffer_].size) {
     ReallocateBuffer(current_buffer_, size);

[alexeypa (please no reviews), 2012/07/02 15:50:11]

nit: We could separate allocation and deletion of the buffers. This way the
logic will be cleaner: the buffers will be allocated before drawing as needed
and freed when screen dimensions change.

[Wez, 2012/07/03 20:56:26]

As discussed, we can't just tear down the buffers when we tear down the device
contexts because the caller may be reading from one of them, so we have to defer
re-allocation of buffers to when we're about to capture into them.

     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;
   }
@@ skipping 91 matching lines @@
 
 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,
+      buffers_[current_buffer_].size.height(), desktop_dc_,
+      GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_YVIRTUALSCREEN),

[alexeypa (please no reviews), 2012/07/02 15:50:11]

There is a race between this code and CapturerGdi::GetScreeenSize(). The screen
dimension should be grabbed only once when the buffers are allocated. 

[Wez, 2012/07/03 20:56:26]

There's no race as such, since the width & height and top/left coordinates can
vary independently of one another. There is a race between this and the DC being
re-allocated, since the DC's origin is what we're actually interested in here,
but that will at worst result in a temporary rendering glitch during
reconfiguration events; it's not avoidable since the displays can be
reconfigured asynchronously to any processing we do here - they could even
change in-between GetSystemMetrics() calls.

I've changed this code to test the coordinates of the desktop, not just the
dimensions, and to fetch the coordinates of the desktop in one place.

       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 157 matching lines @@
 
   // 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));
+  return SkISize::Make(GetSystemMetrics(SM_CXVIRTUALSCREEN),
+                       GetSystemMetrics(SM_CYVIRTUALSCREEN));
 }
 
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   return new CapturerGdi();
 }
 
 }  // namespace remoting