[Chromoting] Use device::PowerSaveBlocker to block screen saver

remoting/test/protocol_perftest.cc

 // Copyright 2014 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.
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/test/test_data_directory.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "remoting/base/auto_thread.h"
+#include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/base/url_request.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/client_user_interface.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vpx.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
@@ skipping 68 matching lines @@
 class ProtocolPerfTest
     : public testing::Test,
       public testing::WithParamInterface<NetworkPerformanceParams>,
       public ClientUserInterface,
       public protocol::VideoRenderer,
       public protocol::VideoStub,
       public protocol::FrameConsumer,
       public HostStatusObserver {
  public:
   ProtocolPerfTest()
-      : host_thread_("host"),
-        capture_thread_("capture"),
-        encode_thread_("encode"),
-        decode_thread_("decode") {
+      : host_thread_(new AutoThreadTaskRunner(
+            message_loop_.task_runner(), run_loop_.QuitClosure())) {

[Sergey Ulanov, 2016/06/27 18:20:24]

Previously the host was running on a separate thread. This moves it to the
current message loop, and I don't think we want to do that.

     protocol::VideoFramePump::EnableTimestampsForTests();
-    host_thread_.StartWithOptions(
-        base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
-    capture_thread_.Start();
-    encode_thread_.Start();
-    decode_thread_.Start();
+    context_ = ChromotingHostContext::Create(host_thread_);
   }
 
   virtual ~ProtocolPerfTest() {
-    host_thread_.task_runner()->DeleteSoon(FROM_HERE, host_.release());
-    host_thread_.task_runner()->DeleteSoon(FROM_HERE,
-                                           host_signaling_.release());
-    message_loop_.RunUntilIdle();
+    host_thread_->DeleteSoon(FROM_HERE, host_.release());
+    host_thread_->DeleteSoon(FROM_HERE, host_signaling_.release());
+    host_thread_->DeleteSoon(FROM_HERE, context_.release());
+    host_thread_ = nullptr;
+    run_loop_.QuitWhenIdle();
   }
 
   // ClientUserInterface interface.
   void OnConnectionState(protocol::ConnectionToHost::State state,
                          protocol::ErrorCode error) override {
     if (state == protocol::ConnectionToHost::CONNECTED) {
       client_connected_ = true;
       if (host_connected_)
         connecting_loop_->Quit();
     }
@@ skipping 28 matching lines @@
 
     if (packet->format().has_screen_width() &&
         packet->format().has_screen_height()) {
       frame_size_.set(packet->format().screen_width(),
                       packet->format().screen_height());
     }
 
     std::unique_ptr<webrtc::DesktopFrame> frame(
         new webrtc::BasicDesktopFrame(frame_size_));
     base::PostTaskAndReplyWithResult(
-        decode_thread_.task_runner().get(), FROM_HERE,
+        context_->video_encode_task_runner().get(), FROM_HERE,

[Sergey Ulanov, 2016/06/27 18:20:24]

We want to use separate threads for encoding and decoding. Otherwise host and
client would interfere with each other, which affects test results.

         base::Bind(&DoDecodeFrame, video_decoder_.get(), packet.get(),
                    base::Passed(&frame)),
         base::Bind(&ProtocolPerfTest::OnFrameDecoded, base::Unretained(this),
                    base::Passed(&packet), done));
   }
 
   void OnFrameDecoded(std::unique_ptr<VideoPacket> packet,
                       const base::Closure& done,
                       std::unique_ptr<webrtc::DesktopFrame> frame) {
     last_video_packet_ = std::move(packet);
@@ skipping 108 matching lines @@
       case ChannelConfig::CODEC_VERBATIM:
         video_decoder_.reset(new VideoDecoderVerbatim());
         break;
       case ChannelConfig::CODEC_VP8:
         video_decoder_ = VideoDecoderVpx::CreateForVP8();
         break;
       default:
         NOTREACHED();
     }
 
-    host_thread_.task_runner()->PostTask(
+    host_thread_->PostTask(
         FROM_HERE,
         base::Bind(&ProtocolPerfTest::StartHost, base::Unretained(this)));
   }
 
   void StartHost() {
-    DCHECK(host_thread_.task_runner()->BelongsToCurrentThread());
+    DCHECK(host_thread_->BelongsToCurrentThread());
 
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
     host_signaling_.reset(new FakeSignalStrategy(kHostJid));
     host_signaling_->ConnectTo(client_signaling_.get());
 
     protocol::NetworkSettings network_settings(
         protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     std::unique_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
     port_allocator_factory->socket_factory()->SetBandwidth(
         GetParam().bandwidth, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
             host_signaling_.get(), std::move(port_allocator_factory), nullptr,
             network_settings, protocol::TransportRole::SERVER));
     std::unique_ptr<protocol::SessionManager> session_manager(
         new protocol::JingleSessionManager(host_signaling_.get()));
     session_manager->set_protocol_config(protocol_config_->Clone());
 
     // Encoder runs on a separate thread, main thread is used for everything
     // else.
     host_.reset(new ChromotingHost(
         &desktop_environment_factory_, std::move(session_manager),
-        transport_context, host_thread_.task_runner(),
-        encode_thread_.task_runner()));
+        transport_context,
+        *context_));
 
     base::FilePath certs_dir(net::GetTestCertsDirectory());
 
     std::string host_cert;
     ASSERT_TRUE(base::ReadFileToString(
         certs_dir.AppendASCII("unittest.selfsigned.der"), &host_cert));
 
     base::FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
     std::string key_string;
     ASSERT_TRUE(base::ReadFileToString(key_path, &key_string));
@@ skipping 110 matching lines @@
             << (total_latency_big_frames / big_frame_count).InMillisecondsF();
 
     if (small_frame_count) {
       VLOG(0)
           << "Average latency for small frames: "
           << (total_latency_small_frames / small_frame_count).InMillisecondsF();
     }
   }
 
   base::MessageLoopForIO message_loop_;
+  base::RunLoop run_loop_;
+
+  std::unique_ptr<ChromotingHostContext> context_;
 
   scoped_refptr<FakeNetworkDispatcher> fake_network_dispatcher_;
 
-  base::Thread host_thread_;
-  base::Thread capture_thread_;
-  base::Thread encode_thread_;
-  base::Thread decode_thread_;
+  scoped_refptr<AutoThreadTaskRunner> host_thread_;

[Sergey Ulanov, 2016/06/27 18:20:24]

this is a task_runner, so it shouldn't be called host_thread_.

   FakeDesktopEnvironmentFactory desktop_environment_factory_;
 
   FakeCursorShapeStub cursor_shape_stub_;
 
   std::unique_ptr<protocol::CandidateSessionConfig> protocol_config_;
 
   std::unique_ptr<FakeSignalStrategy> host_signaling_;
   std::unique_ptr<FakeSignalStrategy> client_signaling_;
 
   std::unique_ptr<ChromotingHost> host_;
@@ skipping 145 matching lines @@
 
 TEST_P(ProtocolPerfTest, TotalLatencyIce) {
   MeasureTotalLatency(false);
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyWebrtc) {
   MeasureTotalLatency(true);
 }
 
 }  // namespace remoting