Removing unused and private methods remoting::Capturer interface.

remoting/host/video_frame_capturer_linux.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 <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
@@ skipping 64 matching lines @@
 class VideoFrameCapturerLinux : public VideoFrameCapturer {
  public:
   VideoFrameCapturerLinux();
   virtual ~VideoFrameCapturerLinux();
 
   bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
 
   // 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:
   void InitXDamage();
 
   // Read and handle all currently-pending XEvents.
   // In the DAMAGE case, process the XDamage events and store the resulting
   // damage rectangles in the VideoFrameCapturerHelper.
   // In all cases, call ScreenConfigurationChanged() in response to any
   // ConfigNotify events.
   void ProcessPendingXEvents();
 
   // Capture screen pixels, and return the data in a new CaptureData object,
   // to be freed by the caller.
   // In the DAMAGE case, the VideoFrameCapturerHelper already holds the list of
   // invalid rectangles from ProcessPendingXEvents().
   // In the non-DAMAGE case, this captures the whole screen, then calculates
   // some invalid rectangles that include any differences between this and the
   // previous capture.
   CaptureData* CaptureFrame();
 
   // Capture the cursor image and call the CursorShapeChangedCallback if it
   // has been set (using SetCursorShapeChangedCallback).
   void CaptureCursor();
 
+  // Called when the screen configuration is changed.
+  void ScreenConfigurationChanged();
+
   // Synchronize the current buffer with |last_buffer_|, by copying pixels from
   // the area of |last_invalid_rects|.
   // Note this only works on the assumption that kNumBuffers == 2, as
   // |last_invalid_rects| holds the differences from the previous buffer and
   // the one prior to that (which will then be the current buffer).
   void SynchronizeFrame();
 
   void DeinitXlib();
 
   // Capture a rectangle from |x_server_pixel_buffer_|, and copy the data into
@@ skipping 164 matching lines @@
 }
 
 void VideoFrameCapturerLinux::Start(
     const CursorShapeChangedCallback& callback) {
   cursor_shape_changed_callback_ = callback;
 }
 
 void VideoFrameCapturerLinux::Stop() {
 }
 
-void VideoFrameCapturerLinux::ScreenConfigurationChanged() {
-  last_buffer_ = NULL;
-  for (int i = 0; i < kNumBuffers; ++i) {
-    buffers_[i].set_needs_update();
-  }
-  helper_.ClearInvalidRegion();
-  x_server_pixel_buffer_.Init(display_);
-}
-
 media::VideoFrame::Format VideoFrameCapturerLinux::pixel_format() const {
   return pixel_format_;
 }
 
-void VideoFrameCapturerLinux::ClearInvalidRegion() {
-  helper_.ClearInvalidRegion();
-}
-
 void VideoFrameCapturerLinux::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void VideoFrameCapturerLinux::InvalidateScreen(const SkISize& size) {
-  helper_.InvalidateScreen(size);
-}
-
-void VideoFrameCapturerLinux::InvalidateFullScreen() {
-  helper_.InvalidateFullScreen();
-  last_buffer_ = NULL;
-}
-
 void VideoFrameCapturerLinux::CaptureInvalidRegion(
     const CaptureCompletedCallback& callback) {
   // Process XEvents for XDamage and cursor shape tracking.
   ProcessPendingXEvents();
 
   // Resize the current buffer if there was a recent change of
   // screen-resolution.
   VideoFrameBuffer &current = buffers_[current_buffer_];
   current.Update(display_, root_window_);
   // Also refresh the Differ helper used by CaptureFrame(), if needed.
@@ skipping 135 matching lines @@
       invalid_region.op(screen_rect, SkRegion::kUnion_Op);
     }
   }
 
   capture_data->mutable_dirty_region() = invalid_region;
   last_invalid_region_ = invalid_region;
   last_buffer_ = buffer.ptr();
   return capture_data;
 }
 
+void VideoFrameCapturerLinux::ScreenConfigurationChanged() {
+  last_buffer_ = NULL;
+  for (int i = 0; i < kNumBuffers; ++i) {
+    buffers_[i].set_needs_update();
+  }
+  helper_.ClearInvalidRegion();
+  x_server_pixel_buffer_.Init(display_);
+}
+
 void VideoFrameCapturerLinux::SynchronizeFrame() {
   // Synchronize the current buffer with the previous one since we do not
   // capture the entire desktop. Note that encoder may be reading from the
   // previous buffer at this time so thread access complaints are false
   // positives.
 
   // TODO(hclam): We can reduce the amount of copying here by subtracting
   // |capturer_helper_|s region from |last_invalid_region_|.
   // http://crbug.com/92354
   DCHECK(last_buffer_);
@@ skipping 132 matching lines @@
   }
   return capturer;
 }
 
 // static
 void VideoFrameCapturer::EnableXDamage(bool enable) {
   g_should_use_x_damage = enable;
 }
 
 }  // namespace remoting