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

remoting/host/chromoting_host_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/chromoting_host.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 40 matching lines @@
 using testing::SaveArg;
 using testing::Sequence;
 
 namespace remoting {
 
 class ChromotingHostTest : public testing::Test {
  public:
   ChromotingHostTest() {}
 
   void SetUp() override {
-    task_runner_ = new AutoThreadTaskRunner(message_loop_.task_runner(),
-                                            base::Bind(&base::DoNothing));
-
     desktop_environment_factory_.reset(new FakeDesktopEnvironmentFactory());
     session_manager_ = new protocol::MockSessionManager();
+    context_ = ChromotingHostContext::CreateForTest(
+            new AutoThreadTaskRunner(message_loop_.task_runner(),
+                base::Bind(&base::DoNothing)));
 
     host_.reset(new ChromotingHost(
         desktop_environment_factory_.get(), base::WrapUnique(session_manager_),
         protocol::TransportContext::ForTests(protocol::TransportRole::SERVER),
-        task_runner_,    // Audio
-        task_runner_));  // Video encode
+        *context_));
     host_->AddStatusObserver(&host_status_observer_);
 
     xmpp_login_ = "host@domain";
     session1_ = new MockSession();
     session2_ = new MockSession();
     session_unowned1_.reset(new MockSession());
     session_unowned2_.reset(new MockSession());
     session_config1_ = SessionConfig::ForTest();
     session_jid1_ = "user@domain/rest-of-jid";
     session_config2_ = SessionConfig::ForTest();
@@ skipping 36 matching lines @@
     connection2_ = owned_connection2_.get();
     connection2_->set_client_stub(&client_stub2_);
   }
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate,
                                 bool reject) {
     std::unique_ptr<protocol::ConnectionToClient> connection = std::move(
         (connection_index == 0) ? owned_connection1_ : owned_connection2_);
     protocol::ConnectionToClient* connection_ptr = connection.get();
-    std::unique_ptr<ClientSession> client(new ClientSession(
-        host_.get(), task_runner_ /* audio_task_runner */,
-        std::move(connection), desktop_environment_factory_.get(),
+    std::unique_ptr<ClientSession> client(new ClientSession(*context_,
+        host_.get(), std::move(connection), desktop_environment_factory_.get(),
         base::TimeDelta(), nullptr, std::vector<HostExtension*>()));
     ClientSession* client_ptr = client.get();
 
     connection_ptr->set_host_stub(client.get());
     get_client(connection_index) = client_ptr;
 
     // |host| is responsible for deleting |client| from now on.
     host_->clients_.push_back(client.release());
 
     if (authenticate) {
       client_ptr->OnConnectionAuthenticated(connection_ptr);
       if (!reject)
         client_ptr->OnConnectionChannelsConnected(connection_ptr);
     } else {
       client_ptr->OnConnectionClosed(connection_ptr,
                                  protocol::AUTHENTICATION_FAILED);
     }
   }
 
   void TearDown() override {
     if (host_)
       ShutdownHost();
-    task_runner_ = nullptr;
+    context_ = nullptr;
 
     message_loop_.RunUntilIdle();
   }
 
   void DisconnectAllClients() {
     host_->DisconnectAllClients();
   }
 
   void NotifyConnectionClosed1() {
     if (session_unowned1_event_handler_) {
@@ skipping 34 matching lines @@
   // Expect that a client is disconnected. The given action will be done after
   // the status observer is notified that the session has finished.
   Expectation ExpectClientDisconnected(int connection_index) {
     return EXPECT_CALL(host_status_observer_,
                        OnClientDisconnected(get_session_jid(connection_index)))
         .RetiresOnSaturation();
   }
 
  protected:
   base::MessageLoop message_loop_;
-  scoped_refptr<AutoThreadTaskRunner> task_runner_;
+  std::unique_ptr<ChromotingHostContext> context_;
   MockConnectionToClientEventHandler handler_;
   std::unique_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
   MockHostStatusObserver host_status_observer_;
   std::unique_ptr<ChromotingHost> host_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
   protocol::FakeConnectionToClient* connection1_;
   std::unique_ptr<protocol::FakeConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
@@ skipping 171 matching lines @@
 
   ExpectClientConnected(0);
   SimulateClientConnection(0, true, false);
 
   ExpectClientDisconnected(0);
   DisconnectAllClients();
   testing::Mock::VerifyAndClearExpectations(&host_status_observer_);
 }
 
 }  // namespace remoting