Use more specific protocol::CursorShapeStub instead of protocol::ClientStub in VideoScheduler.

remoting/host/video_scheduler.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_VIDEO_SCHEDULER_H_
 #define REMOTING_HOST_VIDEO_SCHEDULER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 11 matching lines @@
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace remoting {
 
 class CaptureData;
 class CursorShapeInfo;
 class VideoFrameCapturer;
 
 namespace protocol {
-class ClientStub;
 class CursorShapeInfo;
+class CursorShapeStub;
 class VideoStub;
 }  // namespace protocol
 
 // Class responsible for scheduling frame captures from a VideoFrameCapturer,
 // delivering them to a VideoEncoder to encode, and finally passing the encoded
 // video packets to the specified VideoStub to send on the network.
 //
 // THREADING
 //
 // This class is supplied TaskRunners to use for capture, encode and network
@@ skipping 33 matching lines @@
   // supplied TaskRunners.  Video and cursor shape updates will be pumped to
   // |video_stub| and |client_stub|, which must remain valid until Stop() is
   // called. |capturer| is used to capture frames and must remain valid until
   // the |done_task| supplied to Stop() is executed.
   static scoped_refptr<VideoScheduler> Create(
       scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
       VideoFrameCapturer* capturer,
       scoped_ptr<VideoEncoder> encoder,
-      protocol::ClientStub* client_stub,
+      protocol::CursorShapeStub* cursor_stub,
       protocol::VideoStub* video_stub);
 
   // VideoFrameCapturer::Delegate implementation.
   virtual void OnCaptureCompleted(
       scoped_refptr<CaptureData> capture_data) OVERRIDE;
   virtual void OnCursorShapeChanged(
       scoped_ptr<MouseCursorShape> cursor_shape) OVERRIDE;
 
   // Stop scheduling frame captures.  |done_task| is executed on the network
   // thread when capturing has stopped.  This object cannot be re-used once
@@ skipping 10 matching lines @@
 
  private:
   friend class base::RefCountedThreadSafe<VideoScheduler>;
 
   VideoScheduler(
       scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
       VideoFrameCapturer* capturer,
       scoped_ptr<VideoEncoder> encoder,
-      protocol::ClientStub* client_stub,
+      protocol::CursorShapeStub* cursor_stub,
       protocol::VideoStub* video_stub);
   virtual ~VideoScheduler();
 
   // Capturer thread ----------------------------------------------------------
 
   // Starts the capturer on the capture thread.
   void StartOnCaptureThread();
 
   // Stops scheduling frame captures on the capture thread, and posts
   // |done_task| to the network thread when done.
@@ skipping 37 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   // Used to capture frames. Always accessed on the capture thread.
   VideoFrameCapturer* capturer_;
 
   // Used to encode captured frames. Always accessed on the encode thread.
   scoped_ptr<VideoEncoder> encoder_;
 
   // Interfaces through which video frames and cursor shapes are passed to the
   // client. These members are always accessed on the network thread.
-  protocol::ClientStub* cursor_stub_;
+  protocol::CursorShapeStub* cursor_stub_;
   protocol::VideoStub* video_stub_;
 
   // Timer used to schedule CaptureNextFrame().
   scoped_ptr<base::OneShotTimer<VideoScheduler> > capture_timer_;
 
   // Count the number of recordings (i.e. capture or encode) happening.
   int pending_captures_;
 
   // True if the previous scheduled capture was skipped.
   bool did_skip_frame_;
 
   // True if capture of video frames is paused.
   bool is_paused_;
 
   // This is a number updated by client to trace performance.
   int64 sequence_number_;
 
   // An object to schedule capturing.
   CaptureScheduler scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoScheduler);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_VIDEO_SCHEDULER_H_