Removing unused and private methods remoting::Capturer interface.

remoting/host/video_frame_capturer_mac.mm

 // 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 <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
@@ skipping 144 matching lines @@
 class VideoFrameCapturerMac : public VideoFrameCapturer {
  public:
   VideoFrameCapturerMac();
   virtual ~VideoFrameCapturerMac();
 
   bool Init();
 
   // Overridden from VideoFrameCapturer:
   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 CaptureCursor();
 
   void GlBlitFast(const VideoFrameBuffer& buffer, const SkRegion& region);
   void GlBlitSlow(const VideoFrameBuffer& buffer);
   void CgBlitPreLion(const VideoFrameBuffer& buffer, const SkRegion& region);
   void CgBlitPostLion(const VideoFrameBuffer& buffer, const SkRegion& region);
   void CaptureRegion(const SkRegion& region,
                      const CaptureCompletedCallback& callback);
 
+  // Called when the screen configuration is changed.
+  void ScreenConfigurationChanged();
+
   void ScreenRefresh(CGRectCount count, const CGRect *rect_array);
   void ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
                         size_t count,
                         const CGRect *rect_array);
   void DisplaysReconfigured(CGDirectDisplayID display,
                             CGDisplayChangeSummaryFlags flags);
   static void ScreenRefreshCallback(CGRectCount count,
                                     const CGRect *rect_array,
                                     void *user_parameter);
   static void ScreenUpdateMoveCallback(CGScreenUpdateMoveDelta delta,
@@ skipping 139 matching lines @@
   if (power_assertion_id_display_ != kIOPMNullAssertionID) {
     IOPMAssertionRelease(power_assertion_id_display_);
     power_assertion_id_display_ = kIOPMNullAssertionID;
   }
   if (power_assertion_id_user_ != kIOPMNullAssertionID) {
     IOPMAssertionRelease(power_assertion_id_user_);
     power_assertion_id_user_ = kIOPMNullAssertionID;
   }
 }
 
-void VideoFrameCapturerMac::ScreenConfigurationChanged() {
-  ReleaseBuffers();
-  helper_.ClearInvalidRegion();
-  last_buffer_ = NULL;
-
-  CGDirectDisplayID mainDevice = CGMainDisplayID();
-  int width = CGDisplayPixelsWide(mainDevice);
-  int height = CGDisplayPixelsHigh(mainDevice);
-  InvalidateScreen(SkISize::Make(width, height));
-
-  if (!CGDisplayUsesOpenGLAcceleration(mainDevice)) {
-    VLOG(3) << "OpenGL support not available.";
-    return;
-  }
-
-  if (display_create_image_func_ != NULL) {
-    // No need for any OpenGL support on Lion
-    return;
-  }
-
-  CGLPixelFormatAttribute attributes[] = {
-    kCGLPFAFullScreen,
-    kCGLPFADisplayMask,
-    (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(mainDevice),
-    (CGLPixelFormatAttribute)0
-  };
-  CGLPixelFormatObj pixel_format = NULL;
-  GLint matching_pixel_format_count = 0;
-  CGLError err = CGLChoosePixelFormat(attributes,
-                                      &pixel_format,
-                                      &matching_pixel_format_count);
-  DCHECK_EQ(err, kCGLNoError);
-  err = CGLCreateContext(pixel_format, NULL, &cgl_context_);
-  DCHECK_EQ(err, kCGLNoError);
-  CGLDestroyPixelFormat(pixel_format);
-  CGLSetFullScreen(cgl_context_);
-  CGLSetCurrentContext(cgl_context_);
-
-  size_t buffer_size = width * height * sizeof(uint32_t);
-  pixel_buffer_object_.Init(cgl_context_, buffer_size);
-}
-
 media::VideoFrame::Format VideoFrameCapturerMac::pixel_format() const {
   return pixel_format_;
 }
 
-void VideoFrameCapturerMac::ClearInvalidRegion() {
-  helper_.ClearInvalidRegion();
-}
-
 void VideoFrameCapturerMac::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void VideoFrameCapturerMac::InvalidateScreen(const SkISize& size) {
-  helper_.InvalidateScreen(size);
-}
-
-void VideoFrameCapturerMac::InvalidateFullScreen() {
-  helper_.InvalidateFullScreen();
-}
-
 void VideoFrameCapturerMac::CaptureInvalidRegion(
     const CaptureCompletedCallback& callback) {
   // Only allow captures when the display configuration is not occurring.
   scoped_refptr<CaptureData> data;
 
   // Critical section shared with DisplaysReconfigured(...).
   CHECK(display_configuration_capture_event_.TimedWait(
       base::TimeDelta::FromSeconds(kDisplayReconfigurationTimeoutInSeconds)));
   SkRegion region;
   helper_.SwapInvalidRegion(&region);
@@ skipping 274 matching lines @@
                src_bytes_per_pixel,
                copy_rect);
     }
   }
 }
 
 const SkISize& VideoFrameCapturerMac::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
+void VideoFrameCapturerMac::ScreenConfigurationChanged() {
+  ReleaseBuffers();
+  helper_.ClearInvalidRegion();
+  last_buffer_ = NULL;
+
+  CGDirectDisplayID mainDevice = CGMainDisplayID();
+  int width = CGDisplayPixelsWide(mainDevice);
+  int height = CGDisplayPixelsHigh(mainDevice);
+  helper_.InvalidateScreen(SkISize::Make(width, height));
+
+  if (!CGDisplayUsesOpenGLAcceleration(mainDevice)) {
+    VLOG(3) << "OpenGL support not available.";
+    return;
+  }
+
+  if (display_create_image_func_ != NULL) {
+    // No need for any OpenGL support on Lion
+    return;
+  }
+
+  CGLPixelFormatAttribute attributes[] = {
+    kCGLPFAFullScreen,
+    kCGLPFADisplayMask,
+    (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(mainDevice),
+    (CGLPixelFormatAttribute)0
+  };
+  CGLPixelFormatObj pixel_format = NULL;
+  GLint matching_pixel_format_count = 0;
+  CGLError err = CGLChoosePixelFormat(attributes,
+                                      &pixel_format,
+                                      &matching_pixel_format_count);
+  DCHECK_EQ(err, kCGLNoError);
+  err = CGLCreateContext(pixel_format, NULL, &cgl_context_);
+  DCHECK_EQ(err, kCGLNoError);
+  CGLDestroyPixelFormat(pixel_format);
+  CGLSetFullScreen(cgl_context_);
+  CGLSetCurrentContext(cgl_context_);
+
+  size_t buffer_size = width * height * sizeof(uint32_t);
+  pixel_buffer_object_.Init(cgl_context_, buffer_size);
+}
+
 void VideoFrameCapturerMac::ScreenRefresh(CGRectCount count,
                                           const CGRect* rect_array) {
   SkIRect skirect_array[count];
   for (CGRectCount i = 0; i < count; ++i) {
     skirect_array[i] = CGRectToSkIRect(rect_array[i]);
   }
   SkRegion region;
   region.setRects(skirect_array, count);
   InvalidateRegion(region);
 }
@@ skipping 64 matching lines @@
 VideoFrameCapturer* VideoFrameCapturer::Create() {
   VideoFrameCapturerMac* capturer = new VideoFrameCapturerMac();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting