summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--remoting/host/client_session.cc44
-rw-r--r--remoting/host/client_session.h6
-rw-r--r--remoting/host/video_scheduler.cc (renamed from remoting/host/screen_recorder.cc)92
-rw-r--r--remoting/host/video_scheduler.h (renamed from remoting/host/screen_recorder.h)24
-rw-r--r--remoting/host/video_scheduler_unittest.cc (renamed from remoting/host/screen_recorder_unittest.cc)43
-rw-r--r--remoting/remoting.gyp8
6 files changed, 111 insertions, 106 deletions
diff --git a/remoting/host/client_session.cc b/remoting/host/client_session.cc
index 6bc351f..df72e7f 100644
--- a/remoting/host/client_session.cc
+++ b/remoting/host/client_session.cc
@@ -18,8 +18,8 @@
#include "remoting/host/desktop_environment.h"
#include "remoting/host/desktop_environment_factory.h"
#include "remoting/host/event_executor.h"
-#include "remoting/host/screen_recorder.h"
#include "remoting/host/video_frame_capturer.h"
+#include "remoting/host/video_scheduler.h"
#include "remoting/proto/control.pb.h"
#include "remoting/proto/event.pb.h"
#include "remoting/protocol/client_stub.h"
@@ -126,14 +126,16 @@ void ClientSession::OnConnectionChannelsConnected(
DCHECK_EQ(connection_.get(), connection);
SetDisableInputs(false);
- // Create a ScreenRecorder, passing the message loops that it should run on.
- VideoEncoder* video_encoder =
+ // Create a VideoEncoder based on the session's video channel configuration.
+ scoped_ptr<VideoEncoder> video_encoder =
CreateVideoEncoder(connection_->session()->config());
- video_recorder_ = new ScreenRecorder(capture_task_runner_,
- encode_task_runner_,
- network_task_runner_,
- desktop_environment_->video_capturer(),
- video_encoder);
+
+ // Create a VideoScheduler to capture frames and feed them to the encoder.
+ video_scheduler_ = new VideoScheduler(capture_task_runner_,
+ encode_task_runner_,
+ network_task_runner_,
+ desktop_environment_->video_capturer(),
+ video_encoder.Pass());
++active_recorders_;
if (connection_->session()->config().is_audio_enabled()) {
@@ -149,8 +151,8 @@ void ClientSession::OnConnectionChannelsConnected(
}
// Start the session.
- video_recorder_->AddConnection(connection_.get());
- video_recorder_->Start();
+ video_scheduler_->AddConnection(connection_.get());
+ video_scheduler_->Start();
desktop_environment_->Start(CreateClipboardProxy());
event_handler_->OnSessionChannelsConnected(this);
@@ -183,8 +185,8 @@ void ClientSession::OnSequenceNumberUpdated(
DCHECK(CalledOnValidThread());
DCHECK_EQ(connection_.get(), connection);
- if (video_recorder_.get())
- video_recorder_->UpdateSequenceNumber(sequence_number);
+ if (video_scheduler_.get())
+ video_scheduler_->UpdateSequenceNumber(sequence_number);
event_handler_->OnSessionSequenceNumber(this, sequence_number);
}
@@ -218,10 +220,10 @@ void ClientSession::Stop(const base::Closure& done_task) {
audio_scheduler_ = NULL;
}
- if (video_recorder_.get()) {
- video_recorder_->RemoveConnection(connection_.get());
- video_recorder_->Stop(base::Bind(&ClientSession::OnRecorderStopped, this));
- video_recorder_ = NULL;
+ if (video_scheduler_.get()) {
+ video_scheduler_->RemoveConnection(connection_.get());
+ video_scheduler_->Stop(base::Bind(&ClientSession::OnRecorderStopped, this));
+ video_scheduler_ = NULL;
}
if (!active_recorders_) {
@@ -248,7 +250,7 @@ void ClientSession::SetDisableInputs(bool disable_inputs) {
ClientSession::~ClientSession() {
DCHECK(!active_recorders_);
DCHECK(audio_scheduler_.get() == NULL);
- DCHECK(video_recorder_.get() == NULL);
+ DCHECK(video_scheduler_.get() == NULL);
}
scoped_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
@@ -280,18 +282,18 @@ void ClientSession::OnRecorderStopped() {
// TODO(sergeyu): Move this to SessionManager?
// static
-VideoEncoder* ClientSession::CreateVideoEncoder(
+scoped_ptr<VideoEncoder> ClientSession::CreateVideoEncoder(
const protocol::SessionConfig& config) {
const protocol::ChannelConfig& video_config = config.video_config();
if (video_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
- return new remoting::VideoEncoderVerbatim();
+ return scoped_ptr<VideoEncoder>(new remoting::VideoEncoderVerbatim());
} else if (video_config.codec == protocol::ChannelConfig::CODEC_VP8) {
- return new remoting::VideoEncoderVp8();
+ return scoped_ptr<VideoEncoder>(new remoting::VideoEncoderVp8());
}
NOTIMPLEMENTED();
- return NULL;
+ return scoped_ptr<VideoEncoder>(NULL);
}
// static
diff --git a/remoting/host/client_session.h b/remoting/host/client_session.h
index 126431d..7623cbf 100644
--- a/remoting/host/client_session.h
+++ b/remoting/host/client_session.h
@@ -36,9 +36,9 @@ class AudioScheduler;
struct ClientSessionTraits;
class DesktopEnvironment;
class DesktopEnvironmentFactory;
-class ScreenRecorder;
class VideoEncoder;
class VideoFrameCapturer;
+class VideoScheduler;
// A ClientSession keeps a reference to a connection to a client, and maintains
// per-client state.
@@ -163,7 +163,7 @@ class ClientSession
const protocol::SessionConfig& config);
// Creates a video encoder for the specified configuration.
- static VideoEncoder* CreateVideoEncoder(
+ static scoped_ptr<VideoEncoder> CreateVideoEncoder(
const protocol::SessionConfig& config);
EventHandler* event_handler_;
@@ -222,7 +222,7 @@ class ClientSession
// Schedulers for audio and video capture.
scoped_refptr<AudioScheduler> audio_scheduler_;
- scoped_refptr<ScreenRecorder> video_recorder_;
+ scoped_refptr<VideoScheduler> video_scheduler_;
// Number of screen recorders and audio schedulers that are currently being
// used or shutdown. Used to delay shutdown if one or more
diff --git a/remoting/host/screen_recorder.cc b/remoting/host/video_scheduler.cc
index d9588a1..2031ae1 100644
--- a/remoting/host/screen_recorder.cc
+++ b/remoting/host/video_scheduler.cc
@@ -2,7 +2,7 @@
// 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 "remoting/host/video_scheduler.h"
#include <algorithm>
@@ -32,17 +32,17 @@ namespace remoting {
// TODO(hclam): Move this value to CaptureScheduler.
static const int kMaxRecordings = 2;
-ScreenRecorder::ScreenRecorder(
+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,
- VideoEncoder* encoder)
+ scoped_ptr<VideoEncoder> encoder)
: capture_task_runner_(capture_task_runner),
encode_task_runner_(encode_task_runner),
network_task_runner_(network_task_runner),
capturer_(capturer),
- encoder_(encoder),
+ encoder_(encoder.Pass()),
network_stopped_(false),
encoder_stopped_(false),
max_recordings_(kMaxRecordings),
@@ -56,15 +56,15 @@ ScreenRecorder::ScreenRecorder(
// Public methods --------------------------------------------------------------
-void ScreenRecorder::Start() {
+void VideoScheduler::Start() {
capture_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoStart, this));
+ FROM_HERE, base::Bind(&VideoScheduler::DoStart, this));
}
-void ScreenRecorder::Stop(const base::Closure& done_task) {
+void VideoScheduler::Stop(const base::Closure& done_task) {
if (!capture_task_runner_->BelongsToCurrentThread()) {
capture_task_runner_->PostTask(FROM_HERE, base::Bind(
- &ScreenRecorder::Stop, this, done_task));
+ &VideoScheduler::Stop, this, done_task));
return;
}
@@ -74,18 +74,18 @@ void ScreenRecorder::Stop(const base::Closure& done_task) {
capture_timer_.reset();
network_task_runner_->PostTask(FROM_HERE, base::Bind(
- &ScreenRecorder::DoStopOnNetworkThread, this, done_task));
+ &VideoScheduler::DoStopOnNetworkThread, this, done_task));
}
-void ScreenRecorder::AddConnection(ConnectionToClient* connection) {
+void VideoScheduler::AddConnection(ConnectionToClient* connection) {
DCHECK(network_task_runner_->BelongsToCurrentThread());
connections_.push_back(connection);
capture_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoInvalidateFullScreen, this));
+ FROM_HERE, base::Bind(&VideoScheduler::DoInvalidateFullScreen, this));
}
-void ScreenRecorder::RemoveConnection(ConnectionToClient* connection) {
+void VideoScheduler::RemoveConnection(ConnectionToClient* connection) {
DCHECK(network_task_runner_->BelongsToCurrentThread());
ConnectionToClientList::iterator it =
@@ -95,16 +95,16 @@ void ScreenRecorder::RemoveConnection(ConnectionToClient* connection) {
}
}
-void ScreenRecorder::RemoveAllConnections() {
+void VideoScheduler::RemoveAllConnections() {
DCHECK(network_task_runner_->BelongsToCurrentThread());
connections_.clear();
}
-void ScreenRecorder::UpdateSequenceNumber(int64 sequence_number) {
+void VideoScheduler::UpdateSequenceNumber(int64 sequence_number) {
// Sequence number is used and written only on the capture thread.
if (!capture_task_runner_->BelongsToCurrentThread()) {
capture_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::UpdateSequenceNumber,
+ FROM_HERE, base::Bind(&VideoScheduler::UpdateSequenceNumber,
this, sequence_number));
return;
}
@@ -114,29 +114,29 @@ void ScreenRecorder::UpdateSequenceNumber(int64 sequence_number) {
// Private methods -----------------------------------------------------------
-ScreenRecorder::~ScreenRecorder() {
+VideoScheduler::~VideoScheduler() {
}
-VideoFrameCapturer* ScreenRecorder::capturer() {
+VideoFrameCapturer* VideoScheduler::capturer() {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
DCHECK(capturer_);
return capturer_;
}
-VideoEncoder* ScreenRecorder::encoder() {
+VideoEncoder* VideoScheduler::encoder() {
DCHECK(encode_task_runner_->BelongsToCurrentThread());
DCHECK(encoder_.get());
return encoder_.get();
}
-bool ScreenRecorder::is_recording() {
+bool VideoScheduler::is_recording() {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
return capture_timer_.get() != NULL;
}
// Capturer thread -------------------------------------------------------------
-void ScreenRecorder::DoStart() {
+void VideoScheduler::DoStart() {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
if (is_recording()) {
@@ -145,24 +145,24 @@ void ScreenRecorder::DoStart() {
}
capturer()->Start(
- base::Bind(&ScreenRecorder::CursorShapeChangedCallback, this));
+ base::Bind(&VideoScheduler::CursorShapeChangedCallback, this));
- capture_timer_.reset(new base::OneShotTimer<ScreenRecorder>());
+ capture_timer_.reset(new base::OneShotTimer<VideoScheduler>());
// Capture first frame immedately.
DoCapture();
}
-void ScreenRecorder::StartCaptureTimer() {
+void VideoScheduler::StartCaptureTimer() {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
capture_timer_->Start(FROM_HERE,
scheduler_.NextCaptureDelay(),
this,
- &ScreenRecorder::DoCapture);
+ &VideoScheduler::DoCapture);
}
-void ScreenRecorder::DoCapture() {
+void VideoScheduler::DoCapture() {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
// Make sure we have at most two oustanding recordings. We can simply return
// if we can't make a capture now, the next capture will be started by the
@@ -184,15 +184,15 @@ void ScreenRecorder::DoCapture() {
capture_timer_->Start(FROM_HERE,
scheduler_.NextCaptureDelay(),
this,
- &ScreenRecorder::DoCapture);
+ &VideoScheduler::DoCapture);
// And finally perform one capture.
capture_start_time_ = base::Time::Now();
capturer()->CaptureInvalidRegion(
- base::Bind(&ScreenRecorder::CaptureDoneCallback, this));
+ base::Bind(&VideoScheduler::CaptureDoneCallback, this));
}
-void ScreenRecorder::CaptureDoneCallback(
+void VideoScheduler::CaptureDoneCallback(
scoped_refptr<CaptureData> capture_data) {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
@@ -215,10 +215,10 @@ void ScreenRecorder::CaptureDoneCallback(
}
encode_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoEncode, this, capture_data));
+ FROM_HERE, base::Bind(&VideoScheduler::DoEncode, this, capture_data));
}
-void ScreenRecorder::CursorShapeChangedCallback(
+void VideoScheduler::CursorShapeChangedCallback(
scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
@@ -226,11 +226,11 @@ void ScreenRecorder::CursorShapeChangedCallback(
return;
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoSendCursorShape, this,
+ FROM_HERE, base::Bind(&VideoScheduler::DoSendCursorShape, this,
base::Passed(cursor_shape.Pass())));
}
-void ScreenRecorder::DoFinishOneRecording() {
+void VideoScheduler::DoFinishOneRecording() {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
if (!is_recording())
@@ -247,7 +247,7 @@ void ScreenRecorder::DoFinishOneRecording() {
DoCapture();
}
-void ScreenRecorder::DoInvalidateFullScreen() {
+void VideoScheduler::DoInvalidateFullScreen() {
DCHECK(capture_task_runner_->BelongsToCurrentThread());
SkRegion region;
@@ -258,7 +258,7 @@ void ScreenRecorder::DoInvalidateFullScreen() {
// Network thread --------------------------------------------------------------
-void ScreenRecorder::DoSendVideoPacket(scoped_ptr<VideoPacket> packet) {
+void VideoScheduler::DoSendVideoPacket(scoped_ptr<VideoPacket> packet) {
DCHECK(network_task_runner_->BelongsToCurrentThread());
if (network_stopped_ || connections_.empty())
@@ -266,7 +266,7 @@ void ScreenRecorder::DoSendVideoPacket(scoped_ptr<VideoPacket> packet) {
base::Closure callback;
if ((packet->flags() & VideoPacket::LAST_PARTITION) != 0)
- callback = base::Bind(&ScreenRecorder::VideoFrameSentCallback, this);
+ callback = base::Bind(&VideoScheduler::VideoFrameSentCallback, this);
// TODO(sergeyu): Currently we send the data only to the first
// connection. Send it to all connections if necessary.
@@ -274,17 +274,17 @@ void ScreenRecorder::DoSendVideoPacket(scoped_ptr<VideoPacket> packet) {
packet.Pass(), callback);
}
-void ScreenRecorder::VideoFrameSentCallback() {
+void VideoScheduler::VideoFrameSentCallback() {
DCHECK(network_task_runner_->BelongsToCurrentThread());
if (network_stopped_)
return;
capture_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoFinishOneRecording, this));
+ FROM_HERE, base::Bind(&VideoScheduler::DoFinishOneRecording, this));
}
-void ScreenRecorder::DoStopOnNetworkThread(const base::Closure& done_task) {
+void VideoScheduler::DoStopOnNetworkThread(const base::Closure& done_task) {
DCHECK(network_task_runner_->BelongsToCurrentThread());
// There could be tasks on the network thread when this method is being
@@ -296,11 +296,11 @@ void ScreenRecorder::DoStopOnNetworkThread(const base::Closure& done_task) {
network_stopped_ = true;
encode_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoStopOnEncodeThread,
+ FROM_HERE, base::Bind(&VideoScheduler::DoStopOnEncodeThread,
this, done_task));
}
-void ScreenRecorder::DoSendCursorShape(
+void VideoScheduler::DoSendCursorShape(
scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
DCHECK(network_task_runner_->BelongsToCurrentThread());
@@ -314,7 +314,7 @@ void ScreenRecorder::DoSendCursorShape(
// Encoder thread --------------------------------------------------------------
-void ScreenRecorder::DoEncode(
+void VideoScheduler::DoEncode(
scoped_refptr<CaptureData> capture_data) {
DCHECK(encode_task_runner_->BelongsToCurrentThread());
@@ -327,7 +327,7 @@ void ScreenRecorder::DoEncode(
scoped_ptr<VideoPacket> packet(new VideoPacket());
packet->set_flags(VideoPacket::LAST_PARTITION);
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket,
+ FROM_HERE, base::Bind(&VideoScheduler::DoSendVideoPacket,
this, base::Passed(packet.Pass())));
return;
}
@@ -335,10 +335,10 @@ void ScreenRecorder::DoEncode(
encode_start_time_ = base::Time::Now();
encoder()->Encode(
capture_data, false,
- base::Bind(&ScreenRecorder::EncodedDataAvailableCallback, this));
+ base::Bind(&VideoScheduler::EncodedDataAvailableCallback, this));
}
-void ScreenRecorder::DoStopOnEncodeThread(const base::Closure& done_task) {
+void VideoScheduler::DoStopOnEncodeThread(const base::Closure& done_task) {
DCHECK(encode_task_runner_->BelongsToCurrentThread());
encoder_stopped_ = true;
@@ -349,7 +349,7 @@ void ScreenRecorder::DoStopOnEncodeThread(const base::Closure& done_task) {
capture_task_runner_->PostTask(FROM_HERE, done_task);
}
-void ScreenRecorder::EncodedDataAvailableCallback(
+void VideoScheduler::EncodedDataAvailableCallback(
scoped_ptr<VideoPacket> packet) {
DCHECK(encode_task_runner_->BelongsToCurrentThread());
@@ -366,7 +366,7 @@ void ScreenRecorder::EncodedDataAvailableCallback(
}
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this,
+ FROM_HERE, base::Bind(&VideoScheduler::DoSendVideoPacket, this,
base::Passed(packet.Pass())));
}
diff --git a/remoting/host/screen_recorder.h b/remoting/host/video_scheduler.h
index 07028d3..5296253 100644
--- a/remoting/host/screen_recorder.h
+++ b/remoting/host/video_scheduler.h
@@ -2,8 +2,8 @@
// 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_
+#ifndef REMOTING_HOST_VIDEO_SCHEDULER_H_
+#define REMOTING_HOST_VIDEO_SCHEDULER_H_
#include <vector>
@@ -63,7 +63,7 @@ class CursorShapeInfo;
// | Time
// v
//
-// ScreenRecorder has the following responsibilities:
+// VideoScheduler has the following responsibilities:
// 1. Make sure capture and encode occurs no more frequently than |rate|.
// 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.
@@ -73,16 +73,16 @@ class CursorShapeInfo;
// 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> {
+class VideoScheduler : public base::RefCountedThreadSafe<VideoScheduler> {
public:
- // Construct a ScreenRecorder. Message loops and threads are provided.
+ // Construct a VideoScheduler. Message loops and threads are provided.
// This object does not own capturer but owns encoder.
- ScreenRecorder(
+ VideoScheduler(
scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
VideoFrameCapturer* capturer,
- VideoEncoder* encoder);
+ scoped_ptr<VideoEncoder> encoder);
// Start recording.
void Start();
@@ -104,8 +104,8 @@ class ScreenRecorder : public base::RefCountedThreadSafe<ScreenRecorder> {
void UpdateSequenceNumber(int64 sequence_number);
private:
- friend class base::RefCountedThreadSafe<ScreenRecorder>;
- virtual ~ScreenRecorder();
+ friend class base::RefCountedThreadSafe<VideoScheduler>;
+ virtual ~VideoScheduler();
// Getters for capturer and encoder.
VideoFrameCapturer* capturer();
@@ -174,9 +174,9 @@ class ScreenRecorder : public base::RefCountedThreadSafe<ScreenRecorder> {
ConnectionToClientList connections_;
// Timer that calls DoCapture. Set to NULL when not recording.
- scoped_ptr<base::OneShotTimer<ScreenRecorder> > capture_timer_;
+ scoped_ptr<base::OneShotTimer<VideoScheduler> > capture_timer_;
- // Per-thread flags that are set when the ScreenRecorder is
+ // Per-thread flags that are set when the VideoScheduler is
// stopped. They must be used on the corresponding threads only.
bool network_stopped_;
bool encoder_stopped_;
@@ -203,7 +203,7 @@ class ScreenRecorder : public base::RefCountedThreadSafe<ScreenRecorder> {
// An object to schedule capturing.
CaptureScheduler scheduler_;
- DISALLOW_COPY_AND_ASSIGN(ScreenRecorder);
+ DISALLOW_COPY_AND_ASSIGN(VideoScheduler);
};
} // namespace remoting
diff --git a/remoting/host/screen_recorder_unittest.cc b/remoting/host/video_scheduler_unittest.cc
index 194db96..abaea18 100644
--- a/remoting/host/screen_recorder_unittest.cc
+++ b/remoting/host/video_scheduler_unittest.cc
@@ -2,7 +2,7 @@
// 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 "remoting/host/video_scheduler.h"
#include "base/bind.h"
#include "base/message_loop.h"
@@ -57,8 +57,8 @@ void QuitMessageLoop(MessageLoop* message_loop) {
message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
}
-ACTION_P2(StopScreenRecorder, recorder, task) {
- recorder->Stop(task);
+ACTION_P2(StopVideoScheduler, scheduler, task) {
+ scheduler->Stop(task);
}
} // namespace
@@ -87,13 +87,13 @@ MockVideoEncoder::MockVideoEncoder() {}
MockVideoEncoder::~MockVideoEncoder() {}
-class ScreenRecorderTest : public testing::Test {
+class VideoSchedulerTest : public testing::Test {
public:
- ScreenRecorderTest() {
+ VideoSchedulerTest() {
}
virtual void SetUp() OVERRIDE {
- // VideoFrameCapturer and VideoEncoder are owned by ScreenRecorder.
+ // VideoFrameCapturer and VideoEncoder are owned by VideoScheduler.
encoder_ = new MockVideoEncoder();
session_ = new MockSession();
@@ -103,9 +103,10 @@ class ScreenRecorderTest : public testing::Test {
connection_.reset(new MockConnectionToClient(session_, &host_stub_));
connection_->SetEventHandler(&handler_);
- record_ = new ScreenRecorder(
+ scheduler_ = new VideoScheduler(
message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(),
- message_loop_.message_loop_proxy(), &capturer_, encoder_);
+ message_loop_.message_loop_proxy(), &capturer_,
+ scoped_ptr<remoting::VideoEncoder>(encoder_));
}
virtual void TearDown() OVERRIDE {
@@ -117,26 +118,26 @@ class ScreenRecorderTest : public testing::Test {
protected:
MessageLoop message_loop_;
- scoped_refptr<ScreenRecorder> record_;
+ scoped_refptr<VideoScheduler> scheduler_;
MockConnectionToClientEventHandler handler_;
MockHostStub host_stub_;
MockSession* session_; // Owned by |connection_|.
scoped_ptr<MockConnectionToClient> connection_;
- // The following mock objects are owned by ScreenRecorder.
+ // The following mock objects are owned by VideoScheduler.
MockVideoFrameCapturer capturer_;
MockVideoEncoder* encoder_;
private:
- DISALLOW_COPY_AND_ASSIGN(ScreenRecorderTest);
+ DISALLOW_COPY_AND_ASSIGN(VideoSchedulerTest);
};
-// This test mocks capturer, encoder and network layer to simulate one recording
+// This test mocks capturer, encoder and network layer to simulate one capture
// cycle. When the first encoded packet is submitted to the network
-// ScreenRecorder is instructed to come to a complete stop. We expect the stop
+// VideoScheduler is instructed to come to a complete stop. We expect the stop
// sequence to be executed successfully.
-TEST_F(ScreenRecorderTest, StartAndStop) {
+TEST_F(VideoSchedulerTest, StartAndStop) {
SkRegion update_region(SkIRect::MakeXYWH(0, 0, 10, 10));
DataPlanes planes;
for (int i = 0; i < DataPlanes::kPlaneCount; ++i) {
@@ -172,11 +173,11 @@ TEST_F(ScreenRecorderTest, StartAndStop) {
.WillRepeatedly(FinishSend());
// For the first time when ProcessVideoPacket is received we stop the
- // ScreenRecorder.
+ // VideoScheduler.
EXPECT_CALL(video_stub, ProcessVideoPacketPtr(_, _))
.WillOnce(DoAll(
FinishSend(),
- StopScreenRecorder(record_,
+ StopVideoScheduler(scheduler_,
base::Bind(&QuitMessageLoop, &message_loop_))))
.RetiresOnSaturation();
@@ -184,16 +185,16 @@ TEST_F(ScreenRecorderTest, StartAndStop) {
.After(capturer_capture);
// Add the mock client connection to the session.
- record_->AddConnection(connection_.get());
+ scheduler_->AddConnection(connection_.get());
- // Start the recording.
- record_->Start();
+ // Start capturing.
+ scheduler_->Start();
message_loop_.Run();
}
-TEST_F(ScreenRecorderTest, StopWithoutStart) {
+TEST_F(VideoSchedulerTest, StopWithoutStart) {
EXPECT_CALL(capturer_, Stop());
- record_->Stop(base::Bind(&QuitMessageLoop, &message_loop_));
+ scheduler_->Stop(base::Bind(&QuitMessageLoop, &message_loop_));
message_loop_.Run();
}
diff --git a/remoting/remoting.gyp b/remoting/remoting.gyp
index 6001629..a0b734e 100644
--- a/remoting/remoting.gyp
+++ b/remoting/remoting.gyp
@@ -1590,8 +1590,6 @@
'host/resizing_host_observer.h',
'host/sas_injector.h',
'host/sas_injector_win.cc',
- 'host/screen_recorder.cc',
- 'host/screen_recorder.h',
'host/server_log_entry.cc',
'host/server_log_entry.h',
'host/service_client.cc',
@@ -1618,6 +1616,8 @@
'host/video_frame_capturer_linux.cc',
'host/video_frame_capturer_mac.mm',
'host/video_frame_capturer_win.cc',
+ 'host/video_scheduler.cc',
+ 'host/video_scheduler.h',
'host/vlog_net_log.cc',
'host/vlog_net_log.h',
'host/win/desktop.cc',
@@ -2104,7 +2104,6 @@
'host/register_support_host_request_unittest.cc',
'host/remote_input_filter_unittest.cc',
'host/resizing_host_observer_unittest.cc',
- 'host/screen_recorder_unittest.cc',
'host/server_log_entry_unittest.cc',
'host/setup/oauth_helper_unittest.cc',
'host/setup/pin_validator_unittest.cc',
@@ -2112,6 +2111,9 @@
'host/video_frame_capturer_helper_unittest.cc',
'host/video_frame_capturer_mac_unittest.cc',
'host/video_frame_capturer_unittest.cc',
+ 'host/video_scheduler_unittest.cc',
+ 'host/win/launch_process_with_token.cc',
+ 'host/win/launch_process_with_token.h',
'host/win/worker_process_launcher.cc',
'host/win/worker_process_launcher.h',
'host/win/worker_process_launcher_unittest.cc',
generated by cgit v1.1 at 2025-02-13 04:36:57 +0000