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

remoting/host/chromoting_host_context.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_context.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
@@ skipping 26 matching lines @@
       input_task_runner_(input_task_runner),
       network_task_runner_(network_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
       video_encode_task_runner_(video_encode_task_runner),
       url_request_context_getter_(url_request_context_getter) {
 }
 
 ChromotingHostContext::~ChromotingHostContext() {
 }
 
-std::unique_ptr<ChromotingHostContext> ChromotingHostContext::Copy() {
+std::unique_ptr<ChromotingHostContext> ChromotingHostContext::Copy() const {
   return base::WrapUnique(new ChromotingHostContext(
       ui_task_runner_, audio_task_runner_, file_task_runner_,
       input_task_runner_, network_task_runner_, video_capture_task_runner_,
       video_encode_task_runner_, url_request_context_getter_));
 }
 
 scoped_refptr<AutoThreadTaskRunner> ChromotingHostContext::audio_task_runner()
     const {
   return audio_task_runner_;
 }
@@ skipping 50 matching lines @@
   scoped_refptr<AutoThreadTaskRunner> file_task_runner =
       AutoThread::CreateWithType("ChromotingFileThread", ui_task_runner,
                                  base::MessageLoop::TYPE_IO);
 
   scoped_refptr<AutoThreadTaskRunner> network_task_runner =
       AutoThread::CreateWithType("ChromotingNetworkThread", ui_task_runner,
                                  base::MessageLoop::TYPE_IO);
   network_task_runner->PostTask(FROM_HERE,
                                 base::Bind(&DisallowBlockingOperations));
 
-  return base::WrapUnique(new ChromotingHostContext(
-      ui_task_runner, audio_task_runner, file_task_runner,
+  return Create(ui_task_runner, audio_task_runner, file_task_runner,
       AutoThread::CreateWithType("ChromotingInputThread", ui_task_runner,
                                  base::MessageLoop::TYPE_IO),
       network_task_runner,
       AutoThread::Create("ChromotingCaptureThread", ui_task_runner),
-      AutoThread::Create("ChromotingEncodeThread", ui_task_runner),
-      make_scoped_refptr(
-          new URLRequestContextGetter(network_task_runner, file_task_runner))));
+      AutoThread::Create("ChromotingEncodeThread", ui_task_runner));
+}
+
+// static
+std::unique_ptr<ChromotingHostContext> ChromotingHostContext::CreateForTest(
+    scoped_refptr<AutoThreadTaskRunner> task_runner) {
+  return Create(task_runner, task_runner, task_runner, task_runner, task_runner,
+      task_runner, task_runner);
 }
 
 #if defined(OS_CHROMEOS)
 
 // static
 std::unique_ptr<ChromotingHostContext> ChromotingHostContext::CreateForChromeOS(
     scoped_refptr<net::URLRequestContextGetter> url_request_context_getter,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
@@ skipping 20 matching lines @@
       AutoThread::Create("ChromotingAudioThread", file_auto_task_runner),
       file_auto_task_runner,
       ui_auto_task_runner,  // input_task_runner
       io_auto_task_runner,  // network_task_runner
       ui_auto_task_runner,  // video_capture_task_runner
       AutoThread::Create("ChromotingEncodeThread", file_auto_task_runner),
       url_request_context_getter));
 }
 #endif  // defined(OS_CHROMEOS)
 
+// static
+std::unique_ptr<ChromotingHostContext> ChromotingHostContext::Create(
+      scoped_refptr<AutoThreadTaskRunner> ui_task_runner,
+      scoped_refptr<AutoThreadTaskRunner> audio_task_runner,
+      scoped_refptr<AutoThreadTaskRunner> file_task_runner,
+      scoped_refptr<AutoThreadTaskRunner> input_task_runner,
+      scoped_refptr<AutoThreadTaskRunner> network_task_runner,
+      scoped_refptr<AutoThreadTaskRunner> video_capture_task_runner,
+      scoped_refptr<AutoThreadTaskRunner> video_encode_task_runner) {
+  if (ui_task_runner && audio_task_runner && file_task_runner &&
+      input_task_runner && network_task_runner && video_capture_task_runner &&
+      video_encode_task_runner) {
+  return base::WrapUnique(new ChromotingHostContext(
+      ui_task_runner, audio_task_runner, file_task_runner, input_task_runner,
+      network_task_runner, video_capture_task_runner, video_encode_task_runner,
+      make_scoped_refptr(
+          new URLRequestContextGetter(network_task_runner, file_task_runner))));
+
+  }
+  return std::unique_ptr<ChromotingHostContext>();
+}
+
 }  // namespace remoting