Move screen capturers from remoting/capturer to media/video/capturer/screen

media/video/capture/screen/screen_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/capturer/video_frame_capturer.h"
+#include "media/video/capture/screen/screen_capturer.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 #include <set>
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/file_path.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_native_library.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
-#include "remoting/capturer/capture_data.h"
-#include "remoting/capturer/mac/scoped_pixel_buffer_object.h"
-#include "remoting/capturer/mouse_cursor_shape.h"
-#include "remoting/capturer/video_frame.h"
-#include "remoting/capturer/video_frame_capturer_helper.h"
-#include "remoting/capturer/video_frame_queue.h"
+#include "media/video/capture/screen/mac/scoped_pixel_buffer_object.h"
+#include "media/video/capture/screen/mouse_cursor_shape.h"
+#include "media/video/capture/screen/screen_capture_data.h"
+#include "media/video/capture/screen/screen_capture_frame.h"
+#include "media/video/capture/screen/screen_capture_frame_queue.h"
+#include "media/video/capture/screen/screen_capturer_helper.h"
 
-namespace remoting {
+namespace media {
 
 namespace {
 
 // Definitions used to dynamic-link to deprecated OS 10.6 functions.
 const char* kApplicationServicesLibraryName =
     "/System/Library/Frameworks/ApplicationServices.framework/"
     "ApplicationServices";
 typedef void* (*CGDisplayBaseAddressFunc)(CGDirectDisplayID);
 typedef size_t (*CGDisplayBytesPerRowFunc)(CGDirectDisplayID);
 typedef size_t (*CGDisplayBitsPerPixelFunc)(CGDirectDisplayID);
@@ skipping 33 matching lines @@
     memcpy(dest_plane, src_plane, bytes_per_line);
     src_plane += src_plane_stride;
     dest_plane += dest_plane_stride;
   }
 }
 
 // The amount of time allowed for displays to reconfigure.
 const int64 kDisplayConfigurationEventTimeoutInSeconds = 10;
 
 // A class representing a full-frame pixel buffer.
-class VideoFrameMac : public VideoFrame {
+class ScreenCaptureFrameMac : public ScreenCaptureFrame {
  public:
-  explicit VideoFrameMac(const SkISize& size);
-  virtual ~VideoFrameMac();
+  explicit ScreenCaptureFrameMac(const SkISize& size);
+  virtual ~ScreenCaptureFrameMac();
 
   const SkIPoint& dpi() const { return dpi_; }
 
  private:
   // Allocated pixel buffer.
   scoped_array<uint8> data_;
 
   // DPI settings for this buffer.
   SkIPoint dpi_;
 
-  DISALLOW_COPY_AND_ASSIGN(VideoFrameMac);
+  DISALLOW_COPY_AND_ASSIGN(ScreenCaptureFrameMac);
 };
 
 // A class to perform video frame capturing for mac.
-class VideoFrameCapturerMac : public VideoFrameCapturer {
+class ScreenCapturerMac : public ScreenCapturer {
  public:
-  VideoFrameCapturerMac();
-  virtual ~VideoFrameCapturerMac();
+  ScreenCapturerMac();
+  virtual ~ScreenCapturerMac();
 
   bool Init();
 
-  // Overridden from VideoFrameCapturer:
+  // Overridden from ScreenCapturer:
   virtual void Start(Delegate* delegate) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE;
   virtual void CaptureFrame() OVERRIDE;
 
  private:
   void CaptureCursor();
 
-  void GlBlitFast(const VideoFrame& buffer, const SkRegion& region);
-  void GlBlitSlow(const VideoFrame& buffer);
-  void CgBlitPreLion(const VideoFrame& buffer, const SkRegion& region);
-  void CgBlitPostLion(const VideoFrame& buffer, const SkRegion& region);
+  void GlBlitFast(const ScreenCaptureFrame& buffer, const SkRegion& region);
+  void GlBlitSlow(const ScreenCaptureFrame& buffer);
+  void CgBlitPreLion(const ScreenCaptureFrame& buffer, const SkRegion& region);
+  void CgBlitPostLion(const ScreenCaptureFrame& buffer, const SkRegion& region);
 
   // 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,
                                        size_t count,
                                        const CGRect *rect_array,
                                        void *user_parameter);
   static void DisplaysReconfiguredCallback(CGDirectDisplayID display,
                                            CGDisplayChangeSummaryFlags flags,
                                            void *user_parameter);
 
   void ReleaseBuffers();
 
   Delegate* delegate_;
 
   CGLContextObj cgl_context_;
   ScopedPixelBufferObject pixel_buffer_object_;
 
   // Queue of the frames buffers.
-  VideoFrameQueue queue_;
+  ScreenCaptureFrameQueue queue_;
 
   // Current display configuration.
   std::vector<CGDirectDisplayID> display_ids_;
   SkIRect desktop_bounds_;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
-  VideoFrameCapturerHelper helper_;
+  ScreenCapturerHelper helper_;
 
   // Image of the last cursor that we sent to the client.
   base::mac::ScopedCFTypeRef<CGImageRef> current_cursor_;
 
   // Contains an invalid region from the previous capture.
   SkRegion last_invalid_region_;
 
   // Used to ensure that frame captures do not take place while displays
   // are being reconfigured.
   base::WaitableEvent display_configuration_capture_event_;
 
   // Records the Ids of attached displays which are being reconfigured.
   // Accessed on the thread on which we are notified of display events.
   std::set<CGDirectDisplayID> reconfiguring_displays_;
 
   // Power management assertion to prevent the screen from sleeping.
   IOPMAssertionID power_assertion_id_display_;
 
   // Power management assertion to indicate that the user is active.
   IOPMAssertionID power_assertion_id_user_;
 
   // Dynamically link to deprecated APIs for Mac OS X 10.6 support.
   base::ScopedNativeLibrary app_services_library_;
   CGDisplayBaseAddressFunc cg_display_base_address_;
   CGDisplayBytesPerRowFunc cg_display_bytes_per_row_;
   CGDisplayBitsPerPixelFunc cg_display_bits_per_pixel_;
   base::ScopedNativeLibrary opengl_library_;
   CGLSetFullScreenFunc cgl_set_full_screen_;
 
-  DISALLOW_COPY_AND_ASSIGN(VideoFrameCapturerMac);
+  DISALLOW_COPY_AND_ASSIGN(ScreenCapturerMac);
 };
 
-VideoFrameMac::VideoFrameMac(const SkISize& size) {
+ScreenCaptureFrameMac::ScreenCaptureFrameMac(const SkISize& size) {
   set_bytes_per_row(size.width() * sizeof(uint32_t));
   set_dimensions(size);
 
   size_t buffer_size = size.width() * size.height() * sizeof(uint32_t);
   data_.reset(new  uint8[buffer_size]);
   set_pixels(data_.get());
 
   // TODO(wez): Move the ugly DPI code into a helper.
   NSScreen* screen = [NSScreen mainScreen];
   NSDictionary* attr = [screen deviceDescription];
   NSSize resolution = [[attr objectForKey: NSDeviceResolution] sizeValue];
   dpi_.set(resolution.width, resolution.height);
 }
 
-VideoFrameMac::~VideoFrameMac() {
+ScreenCaptureFrameMac::~ScreenCaptureFrameMac() {
 }
 
-VideoFrameCapturerMac::VideoFrameCapturerMac()
+ScreenCapturerMac::ScreenCapturerMac()
     : delegate_(NULL),
       cgl_context_(NULL),
       display_configuration_capture_event_(false, true),
       power_assertion_id_display_(kIOPMNullAssertionID),
       power_assertion_id_user_(kIOPMNullAssertionID),
       cg_display_base_address_(NULL),
       cg_display_bytes_per_row_(NULL),
       cg_display_bits_per_pixel_(NULL),
       cgl_set_full_screen_(NULL)
 {
 }
 
-VideoFrameCapturerMac::~VideoFrameCapturerMac() {
+ScreenCapturerMac::~ScreenCapturerMac() {
   ReleaseBuffers();
   CGUnregisterScreenRefreshCallback(
-      VideoFrameCapturerMac::ScreenRefreshCallback, this);
+      ScreenCapturerMac::ScreenRefreshCallback, this);
   CGScreenUnregisterMoveCallback(
-      VideoFrameCapturerMac::ScreenUpdateMoveCallback, this);
+      ScreenCapturerMac::ScreenUpdateMoveCallback, this);
   CGError err = CGDisplayRemoveReconfigurationCallback(
-      VideoFrameCapturerMac::DisplaysReconfiguredCallback, this);
+      ScreenCapturerMac::DisplaysReconfiguredCallback, this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGDisplayRemoveReconfigurationCallback " << err;
   }
 }
 
-bool VideoFrameCapturerMac::Init() {
+bool ScreenCapturerMac::Init() {
   CGError err = CGRegisterScreenRefreshCallback(
-      VideoFrameCapturerMac::ScreenRefreshCallback, this);
+      ScreenCapturerMac::ScreenRefreshCallback, this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGRegisterScreenRefreshCallback " << err;
     return false;
   }
 
   err = CGScreenRegisterMoveCallback(
-      VideoFrameCapturerMac::ScreenUpdateMoveCallback, this);
+      ScreenCapturerMac::ScreenUpdateMoveCallback, this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGScreenRegisterMoveCallback " << err;
     return false;
   }
   err = CGDisplayRegisterReconfigurationCallback(
-      VideoFrameCapturerMac::DisplaysReconfiguredCallback, this);
+      ScreenCapturerMac::DisplaysReconfiguredCallback, this);
   if (err != kCGErrorSuccess) {
     LOG(ERROR) << "CGDisplayRegisterReconfigurationCallback " << err;
     return false;
   }
 
   ScreenConfigurationChanged();
   return true;
 }
 
-void VideoFrameCapturerMac::ReleaseBuffers() {
+void ScreenCapturerMac::ReleaseBuffers() {
   if (cgl_context_) {
     pixel_buffer_object_.Release();
     CGLDestroyContext(cgl_context_);
     cgl_context_ = NULL;
   }
   // The buffers might be in use by the encoder, so don't delete them here.
   // Instead, mark them as "needs update"; next time the buffers are used by
   // the capturer, they will be recreated if necessary.
   queue_.SetAllFramesNeedUpdate();
 }
 
-void VideoFrameCapturerMac::Start(Delegate* delegate) {
+void ScreenCapturerMac::Start(Delegate* delegate) {
   DCHECK(delegate_ == NULL);
 
   delegate_ = delegate;
 
   // Create power management assertions to wake the display and prevent it from
   // going to sleep on user idle.
   // TODO(jamiewalch): Use IOPMAssertionDeclareUserActivity on 10.7.3 and above
   //                   instead of the following two assertions.
   IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep,
                               kIOPMAssertionLevelOn,
                               CFSTR("Chrome Remote Desktop connection active"),
                               &power_assertion_id_display_);
   // This assertion ensures that the display is woken up if it  already asleep
   // (as used by Apple Remote Desktop).
   IOPMAssertionCreateWithName(CFSTR("UserIsActive"),
                               kIOPMAssertionLevelOn,
                               CFSTR("Chrome Remote Desktop connection active"),
                               &power_assertion_id_user_);
 }
 
-void VideoFrameCapturerMac::Stop() {
+void ScreenCapturerMac::Stop() {
   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::InvalidateRegion(const SkRegion& invalid_region) {
+void ScreenCapturerMac::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void VideoFrameCapturerMac::CaptureFrame() {
+void ScreenCapturerMac::CaptureFrame() {
   // Only allow captures when the display configuration is not occurring.
-  scoped_refptr<CaptureData> data;
+  scoped_refptr<ScreenCaptureData> data;
 
   base::Time capture_start_time = base::Time::Now();
 
   // Wait until the display configuration is stable. If one or more displays
   // are reconfiguring then |display_configuration_capture_event_| will not be
   // set until the reconfiguration completes.
   // TODO(wez): Replace this with an early-exit (See crbug.com/104542).
   CHECK(display_configuration_capture_event_.TimedWait(
       base::TimeDelta::FromSeconds(
           kDisplayConfigurationEventTimeoutInSeconds)));
 
   SkRegion region;
   helper_.SwapInvalidRegion(&region);
 
   // 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 (queue_.current_frame_needs_update()) {
-    scoped_ptr<VideoFrameMac> buffer(new VideoFrameMac(
+    scoped_ptr<ScreenCaptureFrameMac> buffer(new ScreenCaptureFrameMac(
         SkISize::Make(desktop_bounds_.width(), desktop_bounds_.height())));
-    queue_.ReplaceCurrentFrame(buffer.PassAs<VideoFrame>());
+    queue_.ReplaceCurrentFrame(buffer.PassAs<ScreenCaptureFrame>());
   }
 
-  VideoFrame* current_buffer = queue_.current_frame();
+  ScreenCaptureFrame* current_buffer = queue_.current_frame();
 
   bool flip = false;  // GL capturers need flipping.
   if (base::mac::IsOSLionOrLater()) {
     // Lion requires us to use their new APIs for doing screen capture. These
     // APIS currently crash on 10.6.8 if there is no monitor attached.
     CgBlitPostLion(*current_buffer, region);
   } else if (cgl_context_) {
     flip = true;
     if (pixel_buffer_object_.get() != 0) {
       GlBlitFast(*current_buffer, region);
     } else {
       // See comment in ScopedPixelBufferObject::Init about why the slow
       // path is always used on 10.5.
       GlBlitSlow(*current_buffer);
     }
   } else {
     CgBlitPreLion(*current_buffer, region);
   }
 
   uint8* buffer = current_buffer->pixels();
   int stride = current_buffer->bytes_per_row();
   if (flip) {
     stride = -stride;
     buffer += (current_buffer->dimensions().height() - 1) *
         current_buffer->bytes_per_row();
   }
 
-  data = new CaptureData(buffer, stride, current_buffer->dimensions());
-  data->set_dpi(static_cast<VideoFrameMac*>(current_buffer)->dpi());
+  data = new ScreenCaptureData(buffer, stride, current_buffer->dimensions());
+  data->set_dpi(static_cast<ScreenCaptureFrameMac*>(current_buffer)->dpi());
   data->mutable_dirty_region() = region;
 
   helper_.set_size_most_recent(data->size());
 
   // Signal that we are done capturing data from the display framebuffer,
   // and accessing display structures.
   display_configuration_capture_event_.Signal();
 
   // Capture the current cursor shape and notify |delegate_| if it has changed.
   CaptureCursor();
 
   // Move the capture frame buffer queue on to the next buffer.
   queue_.DoneWithCurrentFrame();
 
   data->set_capture_time_ms(
       (base::Time::Now() - capture_start_time).InMillisecondsRoundedUp());
   delegate_->OnCaptureCompleted(data);
 }
 
-void VideoFrameCapturerMac::CaptureCursor() {
+void ScreenCapturerMac::CaptureCursor() {
   NSCursor* cursor = [NSCursor currentSystemCursor];
   if (cursor == nil) {
     return;
   }
 
   NSImage* nsimage = [cursor image];
   NSPoint hotspot = [cursor hotSpot];
   NSSize size = [nsimage size];
   CGImageRef image = [nsimage CGImageForProposedRect:NULL
                                              context:nil
@@ skipping 55 matching lines @@
   // Create a MouseCursorShape that describes the cursor and pass it to
   // the client.
   scoped_ptr<MouseCursorShape> cursor_shape(new MouseCursorShape());
   cursor_shape->size.set(size.width, size.height);
   cursor_shape->hotspot.set(hotspot.x, hotspot.y);
   cursor_shape->data.assign(cursor_src_data, cursor_src_data + data_size);
 
   delegate_->OnCursorShapeChanged(cursor_shape.Pass());
 }
 
-void VideoFrameCapturerMac::GlBlitFast(const VideoFrame& buffer,
+void ScreenCapturerMac::GlBlitFast(const ScreenCaptureFrame& buffer,
                                        const SkRegion& region) {
   const int buffer_height = buffer.dimensions().height();
   const int buffer_width = buffer.dimensions().width();
 
   // Clip to the size of our current screen.
   SkIRect clip_rect = SkIRect::MakeWH(buffer_width, buffer_height);
   if (queue_.previous_frame()) {
     // We are doing double buffer for the capture data so we just need to copy
     // the invalid region from the previous capture in the current buffer.
     // TODO(hclam): We can reduce the amount of copying here by subtracting
@@ skipping 46 matching lines @@
     // If glUnmapBuffer returns false, then the contents of the data store are
     // undefined. This might be because the screen mode has changed, in which
     // case it will be recreated in ScreenConfigurationChanged, but releasing
     // the object here is the best option. Capturing will fall back on
     // GlBlitSlow until such time as the pixel buffer object is recreated.
     pixel_buffer_object_.Release();
   }
   glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
 }
 
-void VideoFrameCapturerMac::GlBlitSlow(const VideoFrame& buffer) {
+void ScreenCapturerMac::GlBlitSlow(const ScreenCaptureFrame& buffer) {
   CGLContextObj CGL_MACRO_CONTEXT = cgl_context_;
   glReadBuffer(GL_FRONT);
   glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
   glPixelStorei(GL_PACK_ALIGNMENT, 4);  // Force 4-byte alignment.
   glPixelStorei(GL_PACK_ROW_LENGTH, 0);
   glPixelStorei(GL_PACK_SKIP_ROWS, 0);
   glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
   // Read a block of pixels from the frame buffer.
   glReadPixels(0, 0, buffer.dimensions().width(), buffer.dimensions().height(),
                GL_BGRA, GL_UNSIGNED_BYTE, buffer.pixels());
   glPopClientAttrib();
 }
 
-void VideoFrameCapturerMac::CgBlitPreLion(const VideoFrame& buffer,
+void ScreenCapturerMac::CgBlitPreLion(const ScreenCaptureFrame& buffer,
                                           const SkRegion& region) {
   const int buffer_height = buffer.dimensions().height();
 
   // Copy the entire contents of the previous capture buffer, to capture over.
   // TODO(wez): Get rid of this as per crbug.com/145064, or implement
   // crbug.com/92354.
   if (queue_.previous_frame()) {
     memcpy(buffer.pixels(),
            queue_.previous_frame()->pixels(),
            buffer.bytes_per_row() * buffer_height);
@@ skipping 32 matching lines @@
       CopyRect(display_base_address,
                src_bytes_per_row,
                out_ptr,
                buffer.bytes_per_row(),
                src_bytes_per_pixel,
                i.rect());
     }
   }
 }
 
-void VideoFrameCapturerMac::CgBlitPostLion(const VideoFrame& buffer,
+void ScreenCapturerMac::CgBlitPostLion(const ScreenCaptureFrame& buffer,
                                            const SkRegion& region) {
   const int buffer_height = buffer.dimensions().height();
 
   // Copy the entire contents of the previous capture buffer, to capture over.
   // TODO(wez): Get rid of this as per crbug.com/145064, or implement
   // crbug.com/92354.
   if (queue_.previous_frame()) {
     memcpy(buffer.pixels(),
            queue_.previous_frame()->pixels(),
            buffer.bytes_per_row() * buffer_height);
@@ skipping 39 matching lines @@
       CopyRect(display_base_address,
                src_bytes_per_row,
                out_ptr,
                buffer.bytes_per_row(),
                src_bytes_per_pixel,
                i.rect());
     }
   }
 }
 
-void VideoFrameCapturerMac::ScreenConfigurationChanged() {
+void ScreenCapturerMac::ScreenConfigurationChanged() {
   // Release existing buffers, which will be of the wrong size.
   ReleaseBuffers();
 
   // Clear the dirty region, in case the display is down-sizing.
   helper_.ClearInvalidRegion();
 
   // Fetch the list if active displays and calculate their bounds.
   CGDisplayCount display_count;
   CGError error = CGGetActiveDisplayList(0, NULL, &display_count);
   CHECK_EQ(error, CGDisplayNoErr);
@@ skipping 80 matching lines @@
   DCHECK_EQ(err, kCGLNoError);
   CGLDestroyPixelFormat(pixel_format);
   (*cgl_set_full_screen_)(cgl_context_);
   CGLSetCurrentContext(cgl_context_);
 
   size_t buffer_size = desktop_bounds_.width() * desktop_bounds_.height() *
                        sizeof(uint32_t);
   pixel_buffer_object_.Init(cgl_context_, buffer_size);
 }
 
-void VideoFrameCapturerMac::ScreenRefresh(CGRectCount count,
+void ScreenCapturerMac::ScreenRefresh(CGRectCount count,
                                           const CGRect* rect_array) {
   if (desktop_bounds_.isEmpty()) {
     return;
   }
   SkIRect skirect_array[count];
   for (CGRectCount i = 0; i < count; ++i) {
     skirect_array[i] = CGRectToSkIRect(rect_array[i]);
     skirect_array[i].offset(-desktop_bounds_.left(), -desktop_bounds_.top());
   }
   SkRegion region;
   region.setRects(skirect_array, count);
   InvalidateRegion(region);
 }
 
-void VideoFrameCapturerMac::ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
+void ScreenCapturerMac::ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
                                              size_t count,
                                              const CGRect* rect_array) {
   SkIRect skirect_array[count];
   for (CGRectCount i = 0; i < count; ++i) {
     CGRect rect = rect_array[i];
     rect = CGRectOffset(rect, delta.dX, delta.dY);
     skirect_array[i] = CGRectToSkIRect(rect);
     skirect_array[i].offset(-desktop_bounds_.left(), -desktop_bounds_.top());
   }
   SkRegion region;
   region.setRects(skirect_array, count);
   InvalidateRegion(region);
 }
 
-void VideoFrameCapturerMac::DisplaysReconfigured(
+void ScreenCapturerMac::DisplaysReconfigured(
     CGDirectDisplayID display,
     CGDisplayChangeSummaryFlags flags) {
   if (flags & kCGDisplayBeginConfigurationFlag) {
     if (reconfiguring_displays_.empty()) {
       // If this is the first display to start reconfiguring then wait on
       // |display_configuration_capture_event_| to block the capture thread
       // from accessing display memory until the reconfiguration completes.
       CHECK(display_configuration_capture_event_.TimedWait(
                 base::TimeDelta::FromSeconds(
                     kDisplayConfigurationEventTimeoutInSeconds)));
     }
 
     reconfiguring_displays_.insert(display);
   } else {
     reconfiguring_displays_.erase(display);
 
     if (reconfiguring_displays_.empty()) {
       // If no other displays are reconfiguring then refresh capturer data
       // structures and un-block the capturer thread.
       ScreenConfigurationChanged();
       display_configuration_capture_event_.Signal();
     }
   }
 }
 
-void VideoFrameCapturerMac::ScreenRefreshCallback(CGRectCount count,
+void ScreenCapturerMac::ScreenRefreshCallback(CGRectCount count,
                                                   const CGRect* rect_array,
                                                   void* user_parameter) {
-  VideoFrameCapturerMac* capturer = reinterpret_cast<VideoFrameCapturerMac*>(
+  ScreenCapturerMac* capturer = reinterpret_cast<ScreenCapturerMac*>(
       user_parameter);
   if (capturer->desktop_bounds_.isEmpty()) {
     capturer->ScreenConfigurationChanged();
   }
   capturer->ScreenRefresh(count, rect_array);
 }
 
-void VideoFrameCapturerMac::ScreenUpdateMoveCallback(
+void ScreenCapturerMac::ScreenUpdateMoveCallback(
     CGScreenUpdateMoveDelta delta,
     size_t count,
     const CGRect* rect_array,
     void* user_parameter) {
-  VideoFrameCapturerMac* capturer = reinterpret_cast<VideoFrameCapturerMac*>(
+  ScreenCapturerMac* capturer = reinterpret_cast<ScreenCapturerMac*>(
       user_parameter);
   capturer->ScreenUpdateMove(delta, count, rect_array);
 }
 
-void VideoFrameCapturerMac::DisplaysReconfiguredCallback(
+void ScreenCapturerMac::DisplaysReconfiguredCallback(
     CGDirectDisplayID display,
     CGDisplayChangeSummaryFlags flags,
     void* user_parameter) {
-  VideoFrameCapturerMac* capturer = reinterpret_cast<VideoFrameCapturerMac*>(
+  ScreenCapturerMac* capturer = reinterpret_cast<ScreenCapturerMac*>(
       user_parameter);
   capturer->DisplaysReconfigured(display, flags);
 }
 
 }  // namespace
 
 // static
-scoped_ptr<VideoFrameCapturer> VideoFrameCapturer::Create() {
-  scoped_ptr<VideoFrameCapturerMac> capturer(new VideoFrameCapturerMac());
+scoped_ptr<ScreenCapturer> ScreenCapturer::Create() {
+  scoped_ptr<ScreenCapturerMac> capturer(new ScreenCapturerMac());
   if (!capturer->Init())
     capturer.reset();
-  return capturer.PassAs<VideoFrameCapturer>();
+  return capturer.PassAs<ScreenCapturer>();
 }
 
 // static
-scoped_ptr<VideoFrameCapturer> VideoFrameCapturer::CreateWithFactory(
+scoped_ptr<ScreenCapturer> ScreenCapturer::CreateWithFactory(
     SharedBufferFactory* shared_buffer_factory) {
   NOTIMPLEMENTED();
-  return scoped_ptr<VideoFrameCapturer>();
+  return scoped_ptr<ScreenCapturer>();
 }
 
-}  // namespace remoting
+}  // namespace media