Make sure VideoFrameBufferWin::VideoFrameBuffer::resource_generation is properly initialized.

remoting/host/video_frame_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/video_frame_capturer.h"
 
 #include <windows.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
@@ skipping 39 matching lines @@
   virtual void Start(const CursorShapeChangedCallback& callback) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
   virtual void InvalidateRegion(const SkRegion& invalid_region) 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() {
-      data = 0;
-      size = SkISize::Make(0, 0);
-      bytes_per_pixel = 0;
-      bytes_per_row = 0;
-    }
+    VideoFrameBuffer();
+
     void* data;
     SkISize size;
     int bytes_per_pixel;
     int bytes_per_row;
     int resource_generation;
   };
 
   // Make sure that the device contexts and the current bufffer match the screen
   // configuration.
   void PrepareCaptureResources();
 
   // Allocates the specified capture buffer using the current device contexts
   // and desktop dimensions, releasing any pre-existing buffer.
-  void AllocateBuffer(int buffer_index);
+  void AllocateBuffer(int buffer_index, int resource_generation);
 
   void CalculateInvalidRegion();
   void CaptureRegion(const SkRegion& region,
                      const CaptureCompletedCallback& callback);
 
   // Generates an image in the current buffer.
   void CaptureImage();
 
   // Expand the cursor shape to add a white outline for visibility against
   // dark backgrounds.
@@ skipping 43 matching lines @@
   DwmEnableCompositionFunc composition_func_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCapturerWin);
 };
 
 // 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;
 
+VideoFrameCapturerWin::VideoFrameBuffer::VideoFrameBuffer()
+    : data(NULL),
+      size(SkISize::Make(0, 0)),
+      bytes_per_pixel(0),
+      bytes_per_row(0),
+      resource_generation(0) {
+}
+
 VideoFrameCapturerWin::VideoFrameCapturerWin()
     : last_cursor_size_(SkISize::Make(0, 0)),
       desktop_dc_rect_(SkIRect::MakeEmpty()),
       resource_generation_(0),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32),
       composition_func_(NULL) {
 }
 
 VideoFrameCapturerWin::~VideoFrameCapturerWin() {
@@ skipping 92 matching lines @@
     memory_dc_.Set(CreateCompatibleDC(*desktop_dc_));
     desktop_dc_rect_ = screen_rect;
 
     ++resource_generation_;
   }
 
   // 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_);
+    AllocateBuffer(current_buffer_, resource_generation_);
 
     SkRegion region;
     region.op(SkIRect::MakeSize(helper_.size_most_recent()),
               SkRegion::kUnion_Op);
     InvalidateRegion(region);
   }
 }
 
-void VideoFrameCapturerWin::AllocateBuffer(int buffer_index) {
+void VideoFrameCapturerWin::AllocateBuffer(int buffer_index,
+                                           int resource_generation) {
   DCHECK(desktop_dc_.get() != NULL);
   DCHECK(memory_dc_.Get() != NULL);
   // Windows requires DIB sections' rows to start DWORD-aligned, which is
   // implicit when working with RGB32 pixels.
   DCHECK_EQ(pixel_format_, media::VideoFrame::RGB32);
 
   // Describe a device independent bitmap (DIB) that is the size of the desktop.
   BITMAPINFO bmi;
   memset(&bmi, 0, sizeof(bmi));
   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);
   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 the DIB, and store a pointer to its pixel buffer.
   target_bitmap_[buffer_index] =
       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);
+  buffers_[buffer_index].resource_generation = resource_generation;
 }
 
 void VideoFrameCapturerWin::CalculateInvalidRegion() {
   CaptureImage();
 
   const VideoFrameBuffer& current = buffers_[current_buffer_];
 
   // Find the previous and current screens.
   int prev_buffer_id = current_buffer_ - 1;
   if (prev_buffer_id < 0) {
@@ skipping 236 matching lines @@
 }
 
 }  // namespace
 
 // static
 VideoFrameCapturer* VideoFrameCapturer::Create() {
   return new VideoFrameCapturerWin();
 }
 
 }  // namespace remoting