Calling SendSAS() from a service yo make sure that Secure Attention Sequence can be injected even w…

remoting/host/win/session_event_executor.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/win/session_event_executor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 23 matching lines @@
 
 } // namespace
 
 namespace remoting {
 
 using protocol::ClipboardEvent;
 using protocol::MouseEvent;
 using protocol::KeyEvent;
 
 SessionEventExecutorWin::SessionEventExecutorWin(
-    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-    scoped_ptr<EventExecutor> nested_executor)
+    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+    scoped_ptr<EventExecutor> nested_executor,
+    scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
+    const base::Closure& inject_sas)
     : nested_executor_(nested_executor.Pass()),
-      task_runner_(main_task_runner),
+      input_task_runner_(input_task_runner),
+      inject_sas_task_runner_(inject_sas_task_runner),
+      inject_sas_(inject_sas),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       weak_ptr_(weak_ptr_factory_.GetWeakPtr()) {
-  // Let |weak_ptr_| be used on the |task_runner_| thread.
+  // Let |weak_ptr_| be used on the |input_task_runner_| thread.
   // |weak_ptr_| and |weak_ptr_factory_| share a ThreadChecker, so the
   // following line affects both of them.
   weak_ptr_factory_.DetachFromThread();
 }
 
 SessionEventExecutorWin::~SessionEventExecutorWin() {
 }
 
 void SessionEventExecutorWin::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
-  if (!task_runner_->BelongsToCurrentThread()) {
-    task_runner_->PostTask(
+  if (!input_task_runner_->BelongsToCurrentThread()) {
+    input_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SessionEventExecutorWin::Start,
                    weak_ptr_, base::Passed(&client_clipboard)));
     return;
   }
 
   nested_executor_->Start(client_clipboard.Pass());
 }
 
 void SessionEventExecutorWin::StopAndDelete() {
-  if (!task_runner_->BelongsToCurrentThread()) {
-    task_runner_->PostTask(
+  if (!input_task_runner_->BelongsToCurrentThread()) {
+    input_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SessionEventExecutorWin::StopAndDelete,
                    weak_ptr_));
     return;
   }
 
   nested_executor_.release()->StopAndDelete();
   delete this;
 }
 
 void SessionEventExecutorWin::InjectClipboardEvent(
     const ClipboardEvent& event) {
-  if (!task_runner_->BelongsToCurrentThread()) {
-    task_runner_->PostTask(
+  if (!input_task_runner_->BelongsToCurrentThread()) {
+    input_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SessionEventExecutorWin::InjectClipboardEvent,
                    weak_ptr_, event));
     return;
   }
 
   nested_executor_->InjectClipboardEvent(event);
 }
 
 void SessionEventExecutorWin::InjectKeyEvent(const KeyEvent& event) {
-  if (!task_runner_->BelongsToCurrentThread()) {
-    task_runner_->PostTask(
+  if (!input_task_runner_->BelongsToCurrentThread()) {
+    input_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SessionEventExecutorWin::InjectKeyEvent,
                    weak_ptr_, event));
     return;
   }
 
   // HostEventDispatcher should drop events lacking the pressed field.
   DCHECK(event.has_pressed());
 
   if (event.has_usb_keycode()) {
     if (event.pressed()) {
       // Simulate secure attention sequence if Ctrl-Alt-Del was just pressed.
       if (event.usb_keycode() == kUsbDelete &&
           CheckCtrlAndAltArePressed(pressed_keys_)) {
         VLOG(3) << "Sending Secure Attention Sequence to console";
 
-        if (sas_injector_.get() == NULL)
-          sas_injector_ = SasInjector::Create();
-        sas_injector_->InjectSas();
+        if (base::win::GetVersion() < base::win::VERSION_VISTA) {
+          if (!sas_injector_)
+            sas_injector_ = SasInjector::Create();
+          if (!sas_injector_->InjectSas())
+            LOG(ERROR) << "Failed to inject Secure Attention Sequence.";
+        } else {
+          inject_sas_task_runner_->PostTask(FROM_HERE, inject_sas_);
+        }
       }
 
       pressed_keys_.insert(event.usb_keycode());
     } else {
       pressed_keys_.erase(event.usb_keycode());
     }
   }
 
   SwitchToInputDesktop();
   nested_executor_->InjectKeyEvent(event);
 }
 
 void SessionEventExecutorWin::InjectMouseEvent(const MouseEvent& event) {
-  if (!task_runner_->BelongsToCurrentThread()) {
-    task_runner_->PostTask(
+  if (!input_task_runner_->BelongsToCurrentThread()) {
+    input_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SessionEventExecutorWin::InjectMouseEvent,
                    weak_ptr_, event));
     return;
   }
 
   SwitchToInputDesktop();
   nested_executor_->InjectMouseEvent(event);
 }
 
 void SessionEventExecutorWin::SwitchToInputDesktop() {
   // Switch to the desktop receiving user input if different from the current
   // one.
   scoped_ptr<Desktop> input_desktop = Desktop::GetInputDesktop();
   if (input_desktop.get() != NULL && !desktop_.IsSame(*input_desktop)) {
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
     // So we can continue capture screen bits, just from a diffected desktop.
     desktop_.SetThreadDesktop(input_desktop.Pass());
   }
 }
 
 }  // namespace remoting