Rename SessionManager to ScreenRecorder

remoting/host/screen_recorder.cc

Index: remoting/host/screen_recorder.cc
diff --git a/remoting/host/session_manager.cc b/remoting/host/screen_recorder.cc
similarity index 80%
rename from remoting/host/session_manager.cc
rename to remoting/host/screen_recorder.cc
index ebd10614544c4641b3943b1d69751b8b2c479513..7d954e76d18a00044da0d89b5f5179186c1d0819 100644
--- a/remoting/host/session_manager.cc
+++ b/remoting/host/screen_recorder.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/session_manager.h"
+#include "remoting/host/screen_recorder.h"
 
 #include <algorithm>
 
@@ -38,7 +38,7 @@ static const int kSlowDownFactor = 10;
 // capture rate.
 static const int kRateDividers[] = {1, 2, 4, 8, 16};
 
-SessionManager::SessionManager(
+ScreenRecorder::ScreenRecorder(
     MessageLoop* capture_loop,
     MessageLoop* encode_loop,
     MessageLoop* network_loop,
@@ -59,63 +59,63 @@ SessionManager::SessionManager(
   DCHECK(network_loop_);
 }
 
-SessionManager::~SessionManager() {
+ScreenRecorder::~ScreenRecorder() {
   connections_.clear();
 }
 
 // Public methods --------------------------------------------------------------
 
-void SessionManager::Start() {
+void ScreenRecorder::Start() {
   capture_loop_->PostTask(
-      FROM_HERE, NewTracedMethod(this, &SessionManager::DoStart));
+      FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoStart));
 }
 
-void SessionManager::Pause() {
+void ScreenRecorder::Pause() {
   capture_loop_->PostTask(
-      FROM_HERE, NewTracedMethod(this, &SessionManager::DoPause));
+      FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoPause));
 }
 
-void SessionManager::SetMaxRate(double rate) {
+void ScreenRecorder::SetMaxRate(double rate) {
   capture_loop_->PostTask(
-      FROM_HERE, NewTracedMethod(this, &SessionManager::DoSetMaxRate, rate));
+      FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoSetMaxRate, rate));
 }
 
-void SessionManager::AddConnection(
+void ScreenRecorder::AddConnection(
     scoped_refptr<ConnectionToClient> connection) {
   // Gets the init information for the connection.
   capture_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoGetInitInfo, connection));
+      NewTracedMethod(this, &ScreenRecorder::DoGetInitInfo, connection));
 }
 
-void SessionManager::RemoveConnection(
+void ScreenRecorder::RemoveConnection(
     scoped_refptr<ConnectionToClient> connection) {
   network_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoRemoveClient, connection));
+      NewTracedMethod(this, &ScreenRecorder::DoRemoveClient, connection));
 }
 
-void SessionManager::RemoveAllConnections() {
+void ScreenRecorder::RemoveAllConnections() {
   network_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoRemoveAllClients));
+      NewTracedMethod(this, &ScreenRecorder::DoRemoveAllClients));
 }
 
 // Private accessors -----------------------------------------------------------
 
-Capturer* SessionManager::capturer() {
+Capturer* ScreenRecorder::capturer() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
   return capturer_.get();
 }
 
-Encoder* SessionManager::encoder() {
+Encoder* ScreenRecorder::encoder() {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
   return encoder_.get();
 }
 
 // Capturer thread -------------------------------------------------------------
 
-void SessionManager::DoStart() {
+void ScreenRecorder::DoStart() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   if (started_) {
@@ -129,10 +129,10 @@ void SessionManager::DoStart() {
   // Starts the rate regulation.
   network_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoStartRateControl));
+      NewTracedMethod(this, &ScreenRecorder::DoStartRateControl));
 }
 
-void SessionManager::DoPause() {
+void ScreenRecorder::DoPause() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   if (!started_) {
@@ -145,10 +145,10 @@ void SessionManager::DoPause() {
   // Pause the rate regulation.
   network_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoPauseRateControl));
+      NewTracedMethod(this, &ScreenRecorder::DoPauseRateControl));
 }
 
-void SessionManager::DoSetRate(double rate) {
+void ScreenRecorder::DoSetRate(double rate) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
   if (rate == rate_)
     return;
@@ -162,7 +162,7 @@ void SessionManager::DoSetRate(double rate) {
     ScheduleNextCapture();
 }
 
-void SessionManager::DoSetMaxRate(double max_rate) {
+void ScreenRecorder::DoSetMaxRate(double max_rate) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   // TODO(hclam): Should also check for small epsilon.
@@ -174,7 +174,7 @@ void SessionManager::DoSetMaxRate(double max_rate) {
   }
 }
 
-void SessionManager::ScheduleNextCapture() {
+void ScreenRecorder::ScheduleNextCapture() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   ScopedTracer tracer("capture");
@@ -188,11 +188,11 @@ void SessionManager::ScheduleNextCapture() {
       static_cast<int>(base::Time::kMillisecondsPerSecond / rate_));
   capture_loop_->PostDelayedTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoCapture),
+      NewTracedMethod(this, &ScreenRecorder::DoCapture),
       interval.InMilliseconds());
 }
 
-void SessionManager::DoCapture() {
+void ScreenRecorder::DoCapture() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
   // 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
@@ -224,10 +224,10 @@ void SessionManager::DoCapture() {
   DCHECK(capturer());
 
   capturer()->CaptureInvalidRects(
-      NewCallback(this, &SessionManager::CaptureDoneCallback));
+      NewCallback(this, &ScreenRecorder::CaptureDoneCallback));
 }
 
-void SessionManager::CaptureDoneCallback(
+void ScreenRecorder::CaptureDoneCallback(
     scoped_refptr<CaptureData> capture_data) {
   // TODO(hclam): There is a bug if the capturer doesn't produce any dirty
   // rects.
@@ -235,10 +235,10 @@ void SessionManager::CaptureDoneCallback(
   TraceContext::tracer()->PrintString("Capture Done");
   encode_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoEncode, capture_data));
+      NewTracedMethod(this, &ScreenRecorder::DoEncode, capture_data));
 }
 
-void SessionManager::DoFinishEncode() {
+void ScreenRecorder::DoFinishEncode() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   // Decrement the number of recording in process since we have completed
@@ -251,7 +251,7 @@ void SessionManager::DoFinishEncode() {
     DoCapture();
 }
 
-void SessionManager::DoGetInitInfo(
+void ScreenRecorder::DoGetInitInfo(
     scoped_refptr<ConnectionToClient> connection) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
@@ -260,12 +260,12 @@ void SessionManager::DoGetInitInfo(
   // Add the client to the list so it can receive update stream.
   network_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoAddClient, connection));
+      NewTracedMethod(this, &ScreenRecorder::DoAddClient, connection));
 }
 
 // Network thread --------------------------------------------------------------
 
-void SessionManager::DoStartRateControl() {
+void ScreenRecorder::DoStartRateControl() {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   if (rate_control_started_) {
@@ -276,7 +276,7 @@ void SessionManager::DoStartRateControl() {
   ScheduleNextRateControl();
 }
 
-void SessionManager::DoPauseRateControl() {
+void ScreenRecorder::DoPauseRateControl() {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   if (!rate_control_started_) {
@@ -286,15 +286,15 @@ void SessionManager::DoPauseRateControl() {
   rate_control_started_ = false;
 }
 
-void SessionManager::ScheduleNextRateControl() {
+void ScreenRecorder::ScheduleNextRateControl() {
   ScopedTracer tracer("Rate Control");
   network_loop_->PostDelayedTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoRateControl),
+      NewTracedMethod(this, &ScreenRecorder::DoRateControl),
       kRateControlInterval.InMilliseconds());
 }
 
-void SessionManager::DoRateControl() {
+void ScreenRecorder::DoRateControl() {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // If we have been paused then shutdown the rate regulation loop.
@@ -325,11 +325,11 @@ void SessionManager::DoRateControl() {
   // Then set the rate.
   capture_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoSetRate, new_rate));
+      NewTracedMethod(this, &ScreenRecorder::DoSetRate, new_rate));
   ScheduleNextRateControl();
 }
 
-void SessionManager::DoSendVideoPacket(VideoPacket* packet) {
+void ScreenRecorder::DoSendVideoPacket(VideoPacket* packet) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   TraceContext::tracer()->PrintString("DoSendUpdate");
@@ -343,14 +343,14 @@ void SessionManager::DoSendVideoPacket(VideoPacket* packet) {
   TraceContext::tracer()->PrintString("DoSendUpdate done");
 }
 
-void SessionManager::DoAddClient(scoped_refptr<ConnectionToClient> connection) {
+void ScreenRecorder::DoAddClient(scoped_refptr<ConnectionToClient> connection) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // TODO(hclam): Force a full frame for next encode.
   connections_.push_back(connection);
 }
 
-void SessionManager::DoRemoveClient(
+void ScreenRecorder::DoRemoveClient(
     scoped_refptr<ConnectionToClient> connection) {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
@@ -362,7 +362,7 @@ void SessionManager::DoRemoveClient(
   }
 }
 
-void SessionManager::DoRemoveAllClients() {
+void ScreenRecorder::DoRemoveAllClients() {
   DCHECK_EQ(network_loop_, MessageLoop::current());
 
   // Clear the list of connections.
@@ -371,7 +371,7 @@ void SessionManager::DoRemoveAllClients() {
 
 // Encoder thread --------------------------------------------------------------
 
-void SessionManager::DoEncode(
+void ScreenRecorder::DoEncode(
     scoped_refptr<CaptureData> capture_data) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
   TraceContext::tracer()->PrintString("DoEncode called");
@@ -379,7 +379,7 @@ void SessionManager::DoEncode(
   // Early out if there's nothing to encode.
   if (!capture_data->dirty_rects().size()) {
     capture_loop_->PostTask(
-        FROM_HERE, NewTracedMethod(this, &SessionManager::DoFinishEncode));
+        FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoFinishEncode));
     return;
   }
 
@@ -387,11 +387,11 @@ void SessionManager::DoEncode(
   // added.
   TraceContext::tracer()->PrintString("Encode start");
   encoder_->Encode(capture_data, false,
-                   NewCallback(this, &SessionManager::EncodeDataAvailableTask));
+                   NewCallback(this, &ScreenRecorder::EncodeDataAvailableTask));
   TraceContext::tracer()->PrintString("Encode Done");
 }
 
-void SessionManager::EncodeDataAvailableTask(VideoPacket* packet) {
+void ScreenRecorder::EncodeDataAvailableTask(VideoPacket* packet) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   bool last = (packet->flags() & VideoPacket::LAST_PACKET) != 0;
@@ -402,11 +402,11 @@ void SessionManager::EncodeDataAvailableTask(VideoPacket* packet) {
   // task. The ownership will eventually pass to the ConnectionToClients.
   network_loop_->PostTask(
       FROM_HERE,
-      NewTracedMethod(this, &SessionManager::DoSendVideoPacket, packet));
+      NewTracedMethod(this, &ScreenRecorder::DoSendVideoPacket, packet));
 
   if (last) {
     capture_loop_->PostTask(
-        FROM_HERE, NewTracedMethod(this, &SessionManager::DoFinishEncode));
+        FROM_HERE, NewTracedMethod(this, &ScreenRecorder::DoFinishEncode));
   }
 }