Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.

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/message_loop.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 MessageLoopProxy;
+class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace remoting {
 
 namespace protocol {
 class ConnectionToClient;
 class CursorShapeInfo;
 }  // namespace protocol
 
 class CaptureData;
@@ skipping 38 matching lines @@
 // 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(MessageLoop* capture_loop,
-                 MessageLoop* encode_loop,
-                 base::MessageLoopProxy* network_loop,
-                 Capturer* capturer,
-                 Encoder* 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,
+      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);
@@ skipping 52 matching lines @@
   // Encoder thread -----------------------------------------------------------
 
   void DoEncode(scoped_refptr<CaptureData> capture_data);
 
   // Perform stop operations on encode thread.
   void DoStopOnEncodeThread(const base::Closure& done_task);
 
   void EncodedDataAvailableCallback(scoped_ptr<VideoPacket> packet);
   void SendVideoPacket(VideoPacket* packet);
 
-  // Message loops used by this class.
-  MessageLoop* capture_loop_;
-  MessageLoop* encode_loop_;
-  scoped_refptr<base::MessageLoopProxy> network_loop_;
+  // 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_;
 
   // 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.
@@ skipping 30 matching lines @@
 
   // An object to schedule capturing.
   CaptureScheduler scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenRecorder);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_SCREEN_RECORDER_H_