remoting/host: Rename Capturer to VideoFrameCapturer.

remoting/host/screen_recorder.h

 // 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.
 
 #ifndef REMOTING_HOST_SCREEN_RECORDER_H_
 #define REMOTING_HOST_SCREEN_RECORDER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "remoting/base/encoder.h"
-#include "remoting/host/capturer.h"
 #include "remoting/host/capture_scheduler.h"
 #include "remoting/proto/video.pb.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace remoting {
 
+class CaptureData;
+class VideoFrameCapturer;
+
 namespace protocol {
 class ConnectionToClient;
 class CursorShapeInfo;
 }  // namespace protocol
 
-class CaptureData;
-
-// A class for controlling and coordinate Capturer, Encoder
+// A class for controlling and coordinate VideoFrameCapturer, Encoder
 // and NetworkChannel in a record session.
 //
 // THREADING
 //
 // This class works on three threads, namely capture, encode and network
 // thread. The main function of this class is to coordinate and schedule
 // capture, encode and transmission of data on different threads.
 //
 // The following is an example of timeline for operations scheduled.
 //
@@ skipping 23 matching lines @@
 // 2. Make sure there is at most one outstanding capture not being encoded.
 // 3. Distribute tasks on three threads on a timely fashion to minimize latency.
 //
 // This class has the following state variables:
 // |capture_timer_| - If this is set to NULL there should be no activity on
 //                    the capture thread by this object.
 // |network_stopped_| - This state is to prevent activity on the network thread
 //                      if set to false.
 class ScreenRecorder : public base::RefCountedThreadSafe<ScreenRecorder> {
  public:
-
   // Construct a ScreenRecorder. Message loops and threads are provided.
   // This object does not own capturer but owns encoder.
   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);
 
   // Start recording.
   void Start();
 
   // Stop the recording session. |done_task| is executed when recording is fully
   // stopped. This object cannot be used again after |task| is executed.
   void Stop(const base::Closure& done_task);
 
   // Add a connection to this recording session.
   void AddConnection(protocol::ConnectionToClient* connection);
 
   // Remove a connection from receiving screen updates.
   void RemoveConnection(protocol::ConnectionToClient* connection);
 
   // Remove all connections.
   void RemoveAllConnections();
 
   // Update the sequence number for tracing performance.
   void UpdateSequenceNumber(int64 sequence_number);
 
  private:
   friend class base::RefCountedThreadSafe<ScreenRecorder>;
   virtual ~ScreenRecorder();
 
   // Getters for capturer and encoder.
-  Capturer* capturer();
+  VideoFrameCapturer* capturer();
   Encoder* encoder();
 
   bool is_recording();
 
   // Capturer thread ----------------------------------------------------------
 
   void DoStart();
   void DoSetMaxRate(double max_rate);
 
   // Hepler method to schedule next capture using the current rate.
@@ skipping 33 matching lines @@
   void EncodedDataAvailableCallback(scoped_ptr<VideoPacket> packet);
   void SendVideoPacket(VideoPacket* packet);
 
   // Task runners used by this class.
   scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   // Reference to the capturer. This member is always accessed on the capture
   // thread.
-  Capturer* capturer_;
+  VideoFrameCapturer* capturer_;
 
   // Reference to the encoder. This member is always accessed on the encode
   // thread.
   scoped_ptr<Encoder> encoder_;
 
   // A list of clients connected to this hosts.
   // This member is always accessed on the network thread.
   typedef std::vector<protocol::ConnectionToClient*> ConnectionToClientList;
   ConnectionToClientList connections_;
 
@@ skipping 26 matching lines @@
 
   // An object to schedule capturing.
   CaptureScheduler scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenRecorder);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_SCREEN_RECORDER_H_