1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef REMOTING_HOST_FAKE_DESKTOP_ENVIRONMENT_H_
6 #define REMOTING_HOST_FAKE_DESKTOP_ENVIRONMENT_H_
7 
8 #include <cstdint>
9 #include <memory>
10 #include <string>
11 #include <vector>
12 
13 #include "base/macros.h"
14 #include "base/single_thread_task_runner.h"
15 #include "remoting/host/action_executor.h"
16 #include "remoting/host/desktop_environment.h"
17 #include "remoting/host/desktop_environment_options.h"
18 #include "remoting/host/fake_mouse_cursor_monitor.h"
19 #include "remoting/host/input_injector.h"
20 #include "remoting/host/screen_controls.h"
21 #include "remoting/protocol/fake_desktop_capturer.h"
22 
23 namespace remoting {
24 
25 class FakeInputInjector : public InputInjector {
26  public:
27   FakeInputInjector();
28   ~FakeInputInjector() override;
29 
30   void Start(
31       std::unique_ptr<protocol::ClipboardStub> client_clipboard) override;
32   void InjectKeyEvent(const protocol::KeyEvent& event) override;
33   void InjectTextEvent(const protocol::TextEvent& event) override;
34   void InjectMouseEvent(const protocol::MouseEvent& event) override;
35   void InjectTouchEvent(const protocol::TouchEvent& event) override;
36   void InjectClipboardEvent(const protocol::ClipboardEvent& event) override;
37 
set_key_events(std::vector<protocol::KeyEvent> * key_events)38   void set_key_events(std::vector<protocol::KeyEvent>* key_events) {
39     key_events_ = key_events;
40   }
set_text_events(std::vector<protocol::TextEvent> * text_events)41   void set_text_events(std::vector<protocol::TextEvent>* text_events) {
42     text_events_ = text_events;
43   }
set_mouse_events(std::vector<protocol::MouseEvent> * mouse_events)44   void set_mouse_events(std::vector<protocol::MouseEvent>* mouse_events) {
45     mouse_events_ = mouse_events;
46   }
set_touch_events(std::vector<protocol::TouchEvent> * touch_events)47   void set_touch_events(std::vector<protocol::TouchEvent>* touch_events) {
48     touch_events_ = touch_events;
49   }
set_clipboard_events(std::vector<protocol::ClipboardEvent> * clipboard_events)50   void set_clipboard_events(
51       std::vector<protocol::ClipboardEvent>* clipboard_events) {
52     clipboard_events_ = clipboard_events;
53   }
54 
55  private:
56   friend class FakeDesktopEnvironment;
57 
58   std::vector<protocol::KeyEvent>* key_events_ = nullptr;
59   std::vector<protocol::TextEvent>* text_events_ = nullptr;
60   std::vector<protocol::MouseEvent>* mouse_events_ = nullptr;
61   std::vector<protocol::TouchEvent>* touch_events_ = nullptr;
62   std::vector<protocol::ClipboardEvent>* clipboard_events_ = nullptr;
63 
64   base::WeakPtrFactory<FakeInputInjector> weak_factory_{this};
65 
66   DISALLOW_COPY_AND_ASSIGN(FakeInputInjector);
67 };
68 
69 class FakeScreenControls : public ScreenControls {
70  public:
71   FakeScreenControls();
72   ~FakeScreenControls() override;
73 
74   // ScreenControls implementation.
75   void SetScreenResolution(const ScreenResolution& resolution) override;
76 };
77 
78 class FakeDesktopEnvironment : public DesktopEnvironment {
79  public:
80   explicit FakeDesktopEnvironment(
81       scoped_refptr<base::SingleThreadTaskRunner> capture_thread,
82       const DesktopEnvironmentOptions& options);
83   ~FakeDesktopEnvironment() override;
84 
85   // Sets frame generator to be used for protocol::FakeDesktopCapturer created
86   // by FakeDesktopEnvironment.
set_frame_generator(protocol::FakeDesktopCapturer::FrameGenerator frame_generator)87   void set_frame_generator(
88       protocol::FakeDesktopCapturer::FrameGenerator frame_generator) {
89     frame_generator_ = std::move(frame_generator);
90   }
91 
92   const DesktopEnvironmentOptions& options() const;
93 
94   // DesktopEnvironment implementation.
95   std::unique_ptr<ActionExecutor> CreateActionExecutor() override;
96   std::unique_ptr<AudioCapturer> CreateAudioCapturer() override;
97   std::unique_ptr<InputInjector> CreateInputInjector() override;
98   std::unique_ptr<ScreenControls> CreateScreenControls() override;
99   std::unique_ptr<webrtc::DesktopCapturer> CreateVideoCapturer() override;
100   std::unique_ptr<webrtc::MouseCursorMonitor> CreateMouseCursorMonitor()
101       override;
102   std::unique_ptr<KeyboardLayoutMonitor> CreateKeyboardLayoutMonitor(
103       base::RepeatingCallback<void(const protocol::KeyboardLayout&)> callback)
104       override;
105   std::unique_ptr<FileOperations> CreateFileOperations() override;
106   std::string GetCapabilities() const override;
107   void SetCapabilities(const std::string& capabilities) override;
108   uint32_t GetDesktopSessionId() const override;
109   std::unique_ptr<DesktopAndCursorConditionalComposer>
110   CreateComposingVideoCapturer() override;
111 
last_input_injector()112   base::WeakPtr<FakeInputInjector> last_input_injector() {
113     return last_input_injector_;
114   }
115 
116  private:
117   friend class FakeDesktopEnvironmentFactory;
118 
119   scoped_refptr<base::SingleThreadTaskRunner> capture_thread_;
120   protocol::FakeDesktopCapturer::FrameGenerator frame_generator_;
121 
122   base::WeakPtr<FakeInputInjector> last_input_injector_;
123 
124   const DesktopEnvironmentOptions options_;
125 
126   base::WeakPtrFactory<FakeDesktopEnvironment> weak_factory_{this};
127 
128   DISALLOW_COPY_AND_ASSIGN(FakeDesktopEnvironment);
129 };
130 
131 class FakeDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
132  public:
133   explicit FakeDesktopEnvironmentFactory(
134       scoped_refptr<base::SingleThreadTaskRunner> capture_thread);
135   ~FakeDesktopEnvironmentFactory() override;
136 
137   // Sets frame generator to be used for protocol::FakeDesktopCapturer created
138   // by FakeDesktopEnvironment.
set_frame_generator(protocol::FakeDesktopCapturer::FrameGenerator frame_generator)139   void set_frame_generator(
140       protocol::FakeDesktopCapturer::FrameGenerator frame_generator) {
141     frame_generator_ = std::move(frame_generator);
142   }
143 
144   // DesktopEnvironmentFactory implementation.
145   std::unique_ptr<DesktopEnvironment> Create(
146       base::WeakPtr<ClientSessionControl> client_session_control,
147       const DesktopEnvironmentOptions& options) override;
148   bool SupportsAudioCapture() const override;
149 
last_desktop_environment()150   base::WeakPtr<FakeDesktopEnvironment> last_desktop_environment() {
151     return last_desktop_environment_;
152   }
153 
154  private:
155   scoped_refptr<base::SingleThreadTaskRunner> capture_thread_;
156   protocol::FakeDesktopCapturer::FrameGenerator frame_generator_;
157 
158   base::WeakPtr<FakeDesktopEnvironment> last_desktop_environment_;
159 
160   DISALLOW_COPY_AND_ASSIGN(FakeDesktopEnvironmentFactory);
161 };
162 
163 }  // namespace remoting
164 
165 #endif  // REMOTING_HOST_FAKE_DESKTOP_ENVIRONMENT_H_
166