Renamed Encoder -> VideoEncoder.

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"
@@ skipping 64 matching lines @@
 //                      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,
       VideoFrameCapturer* capturer,
-      Encoder* encoder);
+      VideoEncoder* 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.
   VideoFrameCapturer* capturer();
-  Encoder* encoder();
+  VideoEncoder* encoder();
 
   bool is_recording();
 
   // Capturer thread ----------------------------------------------------------
 
   void DoStart();
   void DoSetMaxRate(double max_rate);
 
   // Hepler method to schedule next capture using the current rate.
   void StartCaptureTimer();
@@ skipping 36 matching lines @@
   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.
   VideoFrameCapturer* capturer_;
 
   // Reference to the encoder. This member is always accessed on the encode
   // thread.
-  scoped_ptr<Encoder> encoder_;
+  scoped_ptr<VideoEncoder> 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_;
 
   // Timer that calls DoCapture. Set to NULL when not recording.
   scoped_ptr<base::OneShotTimer<ScreenRecorder> > capture_timer_;
 
   // Per-thread flags that are set when the ScreenRecorder is
@@ skipping 22 matching lines @@
 
   // An object to schedule capturing.
   CaptureScheduler scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenRecorder);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_SCREEN_RECORDER_H_