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

remoting/host/client_session_unittest.cc

 // 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.
 
 #include "remoting/host/client_session.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 78 matching lines @@
   protocol::ClipboardEvent result;
   result.set_mime_type(kMimeTypeTextUtf8);
   result.set_data(text);
   return result;
 }
 
 }  // namespace
 
 class ClientSessionTest : public testing::Test {
  public:
-  ClientSessionTest() : client_jid_("user@domain/rest-of-jid") {}
+  ClientSessionTest()
+      : message_loop_(base::MessageLoop::TYPE_IO),
+        client_jid_("user@domain/rest-of-jid") {}
 
   void SetUp() override;
   void TearDown() override;
 
   // Creates the client session.
   void CreateClientSession();
 
  protected:
   // Notifies the client session that the client connection has been
   // authenticated and channels have been connected. This effectively enables
@@ skipping 52 matching lines @@
 void ClientSessionTest::TearDown() {
   if (client_session_) {
     client_session_->DisconnectSession(protocol::OK);
     client_session_.reset();
     desktop_environment_factory_.reset();
   }
 
   // Clear out |task_runner_| reference so the loop can quit, and run it until
   // it does.
   task_runner_ = nullptr;
-  run_loop_.Run();
+  run_loop_.QuitWhenIdle();
 }
 
 void ClientSessionTest::CreateClientSession() {
   // Mock protocol::Session APIs called directly by ClientSession.
   std::unique_ptr<protocol::MockSession> session(new MockSession());
   EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(*session_config_));
   EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
 
   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
   // HostStub is not touched by ClientSession, so we can safely pass nullptr.
   std::unique_ptr<protocol::FakeConnectionToClient> connection(
       new protocol::FakeConnectionToClient(std::move(session)));
   connection->set_client_stub(&client_stub_);
   connection_ = connection.get();
 
   client_session_.reset(new ClientSession(
+      *ChromotingHostContext::CreateForTest(task_runner_),
       &session_event_handler_,
-      task_runner_,  // Audio thread.
       std::move(connection), desktop_environment_factory_.get(),
       base::TimeDelta(), nullptr, extensions_));
 }
 
 void ClientSessionTest::ConnectClientSession() {
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
 
   // Stubs should be set only after connection is authenticated.
   EXPECT_FALSE(connection_->clipboard_stub());
@@ skipping 208 matching lines @@
   client_session_->DeliverClientMessage(message1);
   protocol::ExtensionMessage message3;
   message3.set_type("ext3");
   message3.set_data("data");
   client_session_->DeliverClientMessage(message3);
   protocol::ExtensionMessage message4;
   message4.set_type("ext4");
   message4.set_data("data");
   client_session_->DeliverClientMessage(message4);
 
-  base::RunLoop().RunUntilIdle();
+  base::RunLoop().QuitWhenIdle();
 
   // ext1 was instantiated and sent a message, and did not wrap anything.
   EXPECT_TRUE(extension1.was_instantiated());
   EXPECT_TRUE(extension1.has_handled_message());
 
   // ext2 was instantiated but not sent a message, and wrapped video encoder.
   EXPECT_TRUE(extension2.was_instantiated());
   EXPECT_FALSE(extension2.has_handled_message());
 
   // ext3 was sent a message but not instantiated.
   EXPECT_FALSE(extension3.was_instantiated());
 }
 
 }  // namespace remoting