Rename Capturer to VideoFrameCapturer.

remoting/host/screen_recorder.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/screen_recorder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "remoting/base/capture_data.h"
+#include "remoting/host/video_frame_capturer.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/message_decoder.h"
 #include "remoting/protocol/util.h"
 
 using remoting::protocol::ConnectionToClient;
 
 namespace remoting {
 
 // Maximum number of frames that can be processed similtaneously.
 // TODO(hclam): Move this value to CaptureScheduler.
 static const int kMaxRecordings = 2;
 
 ScreenRecorder::ScreenRecorder(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    Capturer* capturer,
+    VideoFrameCapturer* capturer,
     Encoder* encoder)
     : capture_task_runner_(capture_task_runner),
       encode_task_runner_(encode_task_runner),
       network_task_runner_(network_task_runner),
       capturer_(capturer),
       encoder_(encoder),
       network_stopped_(false),
       encoder_stopped_(false),
       max_recordings_(kMaxRecordings),
       recordings_(0),
@@ skipping 60 matching lines @@
   }
 
   sequence_number_ = sequence_number;
 }
 
 // Private methods -----------------------------------------------------------
 
 ScreenRecorder::~ScreenRecorder() {
 }
 
-Capturer* ScreenRecorder::capturer() {
+VideoFrameCapturer* ScreenRecorder::capturer() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DCHECK(capturer_);
   return capturer_;
 }
 
 Encoder* ScreenRecorder::encoder() {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
   DCHECK(encoder_.get());
   return encoder_.get();
 }
@@ skipping 230 matching lines @@
     packet->set_encode_time_ms(encode_time_ms);
     scheduler_.RecordEncodeTime(encode_time);
   }
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this,
                             base::Passed(packet.Pass())));
 }
 
 }  // namespace remoting