Adding support for Win+L key combo in Windows host.

remoting/host/win/session_input_injector.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_input_injector.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 16 matching lines @@
 
 bool CheckCtrlAndAltArePressed(const std::set<ui::DomCode>& pressed_keys) {
   size_t ctrl_keys = pressed_keys.count(ui::DomCode::CONTROL_LEFT) +
                      pressed_keys.count(ui::DomCode::CONTROL_RIGHT);
   size_t alt_keys = pressed_keys.count(ui::DomCode::ALT_LEFT) +
                     pressed_keys.count(ui::DomCode::ALT_RIGHT);
   return ctrl_keys != 0 && alt_keys != 0 &&
     (ctrl_keys + alt_keys == pressed_keys.size());
 }
 
+bool IsWinKeyPressed(const std::set<ui::DomCode>& pressed_keys) {
+  size_t win_keys = pressed_keys.count(ui::DomCode::META_LEFT) +
+                    pressed_keys.count(ui::DomCode::META_RIGHT);
+  return win_keys != 0 && win_keys == pressed_keys.size();
+}
+
 } // namespace
 
 namespace remoting {
 
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::MouseEvent;
 using protocol::TextEvent;
 using protocol::TouchEvent;
 
 class SessionInputInjectorWin::Core
     : public base::RefCountedThreadSafe<SessionInputInjectorWin::Core>,
       public InputInjector {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
        std::unique_ptr<InputInjector> nested_executor,
        scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
-       const base::Closure& inject_sas);
+       const base::Closure& inject_sas,
+       const base::Closure& lock_workstation);
 
   // InputInjector implementation.
   void Start(std::unique_ptr<ClipboardStub> client_clipboard) override;
 
   // protocol::ClipboardStub implementation.
   void InjectClipboardEvent(const ClipboardEvent& event) override;
 
   // protocol::InputStub implementation.
   void InjectKeyEvent(const KeyEvent& event) override;
   void InjectTextEvent(const TextEvent& event) override;
   void InjectMouseEvent(const MouseEvent& event) override;
   void InjectTouchEvent(const TouchEvent& event) override;
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   ~Core() override;
 
   // Switches to the desktop receiving a user input if different from
   // the current one.
   void SwitchToInputDesktop();
 
   scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
 
   // Pointer to the next event executor.
   std::unique_ptr<InputInjector> nested_executor_;
 
-  scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> execute_action_task_runner_;
 
   webrtc::ScopedThreadDesktop desktop_;
 
   // Used to inject Secure Attention Sequence on Vista+.
   base::Closure inject_sas_;
 
+  // Used to lock the current session on non-home SKUs of Windows.
+  base::Closure lock_workstation_;
+
   // Used to inject Secure Attention Sequence on XP.
   std::unique_ptr<SasInjector> sas_injector_;
 
-  // Keys currently pressed by the client, used to detect Ctrl-Alt-Del.
+  // Keys currently pressed by the client, used to detect key sequences.
   std::set<ui::DomCode> pressed_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 SessionInputInjectorWin::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     std::unique_ptr<InputInjector> nested_executor,
-    scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
-    const base::Closure& inject_sas)
+    scoped_refptr<base::SingleThreadTaskRunner> execute_action_task_runner,
+    const base::Closure& inject_sas,
+    const base::Closure& lock_workstation)
     : input_task_runner_(input_task_runner),
       nested_executor_(std::move(nested_executor)),
-      inject_sas_task_runner_(inject_sas_task_runner),
-      inject_sas_(inject_sas) {}
+      execute_action_task_runner_(execute_action_task_runner),
+      inject_sas_(inject_sas),
+      lock_workstation_(lock_workstation) {}
 
 void SessionInputInjectorWin::Core::Start(
     std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   if (!input_task_runner_->BelongsToCurrentThread()) {
     input_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Core::Start, this, base::Passed(&client_clipboard)));
     return;
   }
 
@@ skipping 28 matching lines @@
       if (dom_code == ui::DomCode::DEL &&
           CheckCtrlAndAltArePressed(pressed_keys_)) {
         VLOG(3) << "Sending Secure Attention Sequence to the session";
 
         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_);
+          execute_action_task_runner_->PostTask(FROM_HERE, inject_sas_);
         }
+      } else if (dom_code == ui::DomCode::US_L &&
+                 IsWinKeyPressed(pressed_keys_)) {
+        execute_action_task_runner_->PostTask(FROM_HERE, lock_workstation_);
       }
 
       pressed_keys_.insert(dom_code);
     } else {
       pressed_keys_.erase(dom_code);
     }
   }
 
   SwitchToInputDesktop();
   nested_executor_->InjectKeyEvent(event);
@@ skipping 44 matching lines @@
     // 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.release());
   }
 }
 
 SessionInputInjectorWin::SessionInputInjectorWin(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     std::unique_ptr<InputInjector> nested_executor,
     scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
-    const base::Closure& inject_sas) {
+    const base::Closure& inject_sas,
+    const base::Closure& lock_workstation) {
   core_ = new Core(input_task_runner, std::move(nested_executor),
-                   inject_sas_task_runner, inject_sas);
+                   inject_sas_task_runner, inject_sas, lock_workstation);
 }
 
 SessionInputInjectorWin::~SessionInputInjectorWin() {
 }
 
 void SessionInputInjectorWin::Start(
     std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   core_->Start(std::move(client_clipboard));
 }
 
@@ skipping 15 matching lines @@
     const protocol::MouseEvent& event) {
   core_->InjectMouseEvent(event);
 }
 
 void SessionInputInjectorWin::InjectTouchEvent(
     const protocol::TouchEvent& event) {
   core_->InjectTouchEvent(event);
 }
 
 }  // namespace remoting