Removing unused and private methods remoting::Capturer interface.

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 31 matching lines @@
 // 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 Start(const CursorShapeChangedCallback& callback) OVERRIDE;
   virtual void Stop() OVERRIDE;
-  virtual void ScreenConfigurationChanged() OVERRIDE;
   virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
-  virtual void ClearInvalidRegion() OVERRIDE;
   virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE;
-  virtual void InvalidateScreen(const SkISize& size) OVERRIDE;
-  virtual void InvalidateFullScreen() 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) {
@@ skipping 81 matching lines @@
 // 32 bit RGBA is 4 bytes per pixel.
 static const int kBytesPerPixel = 4;
 
 CapturerGdi::CapturerGdi()
     : 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) {
-  ScreenConfigurationChanged();
 }
 
 CapturerGdi::~CapturerGdi() {
 }
 
 media::VideoFrame::Format CapturerGdi::pixel_format() const {
   return pixel_format_;
 }
 
-void CapturerGdi::ClearInvalidRegion() {
-  helper_.ClearInvalidRegion();
-}
-
 void CapturerGdi::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void CapturerGdi::InvalidateScreen(const SkISize& size) {
-  helper_.InvalidateScreen(size);
-}
-
-void CapturerGdi::InvalidateFullScreen() {
-  helper_.InvalidateFullScreen();
-}
-
 void CapturerGdi::CaptureInvalidRegion(
     const CaptureCompletedCallback& callback) {
   // Force the system to power-up display hardware, if it has been suspended.
   SetThreadExecutionState(ES_DISPLAY_REQUIRED);
 
   // Perform the capture.
   CalculateInvalidRegion();
   SkRegion invalid_region;
   helper_.SwapInvalidRegion(&invalid_region);
   CaptureRegion(invalid_region, callback);
@@ skipping 29 matching lines @@
   }
 }
 
 void CapturerGdi::Stop() {
   // 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::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.
     desktop_dc_.reset();
     memory_dc_.Set(NULL);
 
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
@@ skipping 24 matching lines @@
     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_);
-    InvalidateFullScreen();
+
+    SkRegion region;
+    region.op(SkIRect::MakeSize(helper_.size_most_recent()),
+              SkRegion::kUnion_Op);
+    InvalidateRegion(region);
   }
 }
 
 void CapturerGdi::AllocateBuffer(int buffer_index) {
   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);
@@ skipping 32 matching lines @@
   int prev_buffer_id = current_buffer_ - 1;
   if (prev_buffer_id < 0) {
     prev_buffer_id = kNumBuffers - 1;
   }
   const VideoFrameBuffer& prev = buffers_[prev_buffer_id];
 
   // Maybe the previous and current screens can't be differenced.
   if ((current.size != prev.size) ||
       (current.bytes_per_pixel != prev.bytes_per_pixel) ||
       (current.bytes_per_row != prev.bytes_per_row)) {
-    InvalidateScreen(current.size);
+    helper_.InvalidateScreen(current.size);
     return;
   }
 
   // Make sure the differencer is set up correctly for these previous and
   // current screens.
   if (!differ_.get() ||
       (differ_->width() != current.size.width()) ||
       (differ_->height() != current.size.height()) ||
       (differ_->bytes_per_pixel() != current.bytes_per_pixel) ||
       (differ_->bytes_per_row() != current.bytes_per_row)) {
@@ skipping 214 matching lines @@
 }
 
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   return new CapturerGdi();
 }
 
 }  // namespace remoting