remoting/host/desktop_session_win.cc

   1 // Copyright (c) 2012 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 #include "remoting/host/desktop_session_win.h"
   6
   7 #include <limits>
   8 #include <sddl.h>
   9
  10 #include "base/base_switches.h"
  11 #include "base/command_line.h"
  12 #include "base/files/file_path.h"
  13 #include "base/guid.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/weak_ptr.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/threading/thread_checker.h"
  20 #include "base/timer/timer.h"
  21 #include "base/win/scoped_bstr.h"
  22 #include "base/win/scoped_comptr.h"
  23 #include "base/win/scoped_handle.h"
  24 #include "base/win/windows_version.h"
  25 #include "ipc/ipc_message_macros.h"
  26 #include "ipc/ipc_platform_file.h"
  27 #include "remoting/base/auto_thread_task_runner.h"
  28 // MIDL-generated declarations and definitions.
  29 #include "remoting/host/chromoting_lib.h"
  30 #include "remoting/host/chromoting_messages.h"
  31 #include "remoting/host/daemon_process.h"
  32 #include "remoting/host/desktop_session.h"
  33 #include "remoting/host/host_main.h"
  34 #include "remoting/host/ipc_constants.h"
  35 #include "remoting/host/sas_injector.h"
  36 #include "remoting/host/screen_resolution.h"
  37 #include "remoting/host/win/host_service.h"
  38 #include "remoting/host/win/worker_process_launcher.h"
  39 #include "remoting/host/win/wts_session_process_delegate.h"
  40 #include "remoting/host/win/wts_terminal_monitor.h"
  41 #include "remoting/host/win/wts_terminal_observer.h"
  42 #include "remoting/host/worker_process_ipc_delegate.h"
  43
  44 using base::win::ScopedHandle;
  45
  46 namespace remoting {
  47
  48 namespace {
  49
  50 // The security descriptor of the daemon IPC endpoint. It gives full access
  51 // to SYSTEM and denies access by anyone else.
  52 const wchar_t kDaemonIpcSecurityDescriptor[] =
  53     SDDL_OWNER L":" SDDL_LOCAL_SYSTEM
  54     SDDL_GROUP L":" SDDL_LOCAL_SYSTEM
  55     SDDL_DACL L":("
  56         SDDL_ACCESS_ALLOWED L";;" SDDL_GENERIC_ALL L";;;" SDDL_LOCAL_SYSTEM
  57     L")";
  58
  59 // The command line parameters that should be copied from the service's command
  60 // line to the desktop process.
  61 const char* kCopiedSwitchNames[] = { switches::kV, switches::kVModule };
  62
  63 // The default screen dimensions for an RDP session.
  64 const int kDefaultRdpScreenWidth = 1280;
  65 const int kDefaultRdpScreenHeight = 768;
  66
  67 // RDC 6.1 (W2K8) supports dimensions of up to 4096x2048.
  68 const int kMaxRdpScreenWidth = 4096;
  69 const int kMaxRdpScreenHeight = 2048;
  70
  71 // The minimum effective screen dimensions supported by Windows are 800x600.
  72 const int kMinRdpScreenWidth = 800;
  73 const int kMinRdpScreenHeight = 600;
  74
  75 // Default dots per inch used by RDP is 96 DPI.
  76 const int kDefaultRdpDpi = 96;
  77
  78 // The session attach notification should arrive within 30 seconds.
  79 const int kSessionAttachTimeoutSeconds = 30;
  80
  81 // DesktopSession implementation which attaches to the host's physical console.
  82 // Receives IPC messages from the desktop process, running in the console
  83 // session, via |WorkerProcessIpcDelegate|, and monitors console session
  84 // attach/detach events via |WtsConsoleObserer|.
  85 class ConsoleSession : public DesktopSessionWin {
  86  public:
  87   // Same as DesktopSessionWin().
  88   ConsoleSession(
  89     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
  90     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
  91     DaemonProcess* daemon_process,
  92     int id,
  93     WtsTerminalMonitor* monitor);
  94   virtual ~ConsoleSession();
  95
  96  protected:
  97   // DesktopSession overrides.
  98   virtual void SetScreenResolution(const ScreenResolution& resolution) override;
  99
 100   // DesktopSessionWin overrides.
 101   virtual void InjectSas() override;
 102
 103  private:
 104   scoped_ptr<SasInjector> sas_injector_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(ConsoleSession);
 107 };
 108
 109 // DesktopSession implementation which attaches to virtual RDP console.
 110 // Receives IPC messages from the desktop process, running in the console
 111 // session, via |WorkerProcessIpcDelegate|, and monitors console session
 112 // attach/detach events via |WtsConsoleObserer|.
 113 class RdpSession : public DesktopSessionWin {
 114  public:
 115   // Same as DesktopSessionWin().
 116   RdpSession(
 117     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
 118     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
 119     DaemonProcess* daemon_process,
 120     int id,
 121     WtsTerminalMonitor* monitor);
 122   virtual ~RdpSession();
 123
 124   // Performs the part of initialization that can fail.
 125   bool Initialize(const ScreenResolution& resolution);
 126
 127   // Mirrors IRdpDesktopSessionEventHandler.
 128   void OnRdpConnected();
 129   void OnRdpClosed();
 130
 131  protected:
 132   // DesktopSession overrides.
 133   virtual void SetScreenResolution(const ScreenResolution& resolution) override;
 134
 135   // DesktopSessionWin overrides.
 136   virtual void InjectSas() override;
 137
 138  private:
 139   // An implementation of IRdpDesktopSessionEventHandler interface that forwards
 140   // notifications to the owning desktop session.
 141   class EventHandler : public IRdpDesktopSessionEventHandler {
 142    public:
 143     explicit EventHandler(base::WeakPtr<RdpSession> desktop_session);
 144     virtual ~EventHandler();
 145
 146     // IUnknown interface.
 147     STDMETHOD_(ULONG, AddRef)() override;
 148     STDMETHOD_(ULONG, Release)() override;
 149     STDMETHOD(QueryInterface)(REFIID riid, void** ppv) override;
 150
 151     // IRdpDesktopSessionEventHandler interface.
 152     STDMETHOD(OnRdpConnected)() override;
 153     STDMETHOD(OnRdpClosed)() override;
 154
 155    private:
 156     ULONG ref_count_;
 157
 158     // Points to the desktop session object receiving OnRdpXxx() notifications.
 159     base::WeakPtr<RdpSession> desktop_session_;
 160
 161     // This class must be used on a single thread.
 162     base::ThreadChecker thread_checker_;
 163
 164     DISALLOW_COPY_AND_ASSIGN(EventHandler);
 165   };
 166
 167   // Used to create an RDP desktop session.
 168   base::win::ScopedComPtr<IRdpDesktopSession> rdp_desktop_session_;
 169
 170   // Used to match |rdp_desktop_session_| with the session it is attached to.
 171   std::string terminal_id_;
 172
 173   base::WeakPtrFactory<RdpSession> weak_factory_;
 174
 175   DISALLOW_COPY_AND_ASSIGN(RdpSession);
 176 };
 177
 178 ConsoleSession::ConsoleSession(
 179     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
 180     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
 181     DaemonProcess* daemon_process,
 182     int id,
 183     WtsTerminalMonitor* monitor)
 184     : DesktopSessionWin(caller_task_runner, io_task_runner, daemon_process, id,
 185                         monitor) {
 186   StartMonitoring(WtsTerminalMonitor::kConsole);
 187 }
 188
 189 ConsoleSession::~ConsoleSession() {
 190 }
 191
 192 void ConsoleSession::SetScreenResolution(const ScreenResolution& resolution) {
 193   // Do nothing. The screen resolution of the console session is controlled by
 194   // the DesktopSessionAgent instance running in that session.
 195   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 196 }
 197
 198 void ConsoleSession::InjectSas() {
 199   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 200
 201   if (!sas_injector_)
 202     sas_injector_ = SasInjector::Create();
 203   if (!sas_injector_->InjectSas())
 204     LOG(ERROR) << "Failed to inject Secure Attention Sequence.";
 205 }
 206
 207 RdpSession::RdpSession(
 208     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
 209     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
 210     DaemonProcess* daemon_process,
 211     int id,
 212     WtsTerminalMonitor* monitor)
 213     : DesktopSessionWin(caller_task_runner, io_task_runner, daemon_process, id,
 214                         monitor),
 215       weak_factory_(this) {
 216 }
 217
 218 RdpSession::~RdpSession() {
 219 }
 220
 221 bool RdpSession::Initialize(const ScreenResolution& resolution) {
 222   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 223
 224   // Create the RDP wrapper object.
 225   HRESULT result = rdp_desktop_session_.CreateInstance(
 226       __uuidof(RdpDesktopSession));
 227   if (FAILED(result)) {
 228     LOG(ERROR) << "Failed to create RdpSession object, 0x"
 229                << std::hex << result << std::dec << ".";
 230     return false;
 231   }
 232
 233   ScreenResolution local_resolution = resolution;
 234
 235   // If the screen resolution is not specified, use the default screen
 236   // resolution.
 237   if (local_resolution.IsEmpty()) {
 238     local_resolution = ScreenResolution(
 239         webrtc::DesktopSize(kDefaultRdpScreenWidth, kDefaultRdpScreenHeight),
 240         webrtc::DesktopVector(kDefaultRdpDpi, kDefaultRdpDpi));
 241   }
 242
 243   // Get the screen dimensions assuming the default DPI.
 244   webrtc::DesktopSize host_size = local_resolution.ScaleDimensionsToDpi(
 245       webrtc::DesktopVector(kDefaultRdpDpi, kDefaultRdpDpi));
 246
 247   // Make sure that the host resolution is within the limits supported by RDP.
 248   host_size = webrtc::DesktopSize(
 249       std::min(kMaxRdpScreenWidth,
 250                std::max(kMinRdpScreenWidth, host_size.width())),
 251       std::min(kMaxRdpScreenHeight,
 252                std::max(kMinRdpScreenHeight, host_size.height())));
 253
 254   // Create an RDP session.
 255   base::win::ScopedComPtr<IRdpDesktopSessionEventHandler> event_handler(
 256       new EventHandler(weak_factory_.GetWeakPtr()));
 257   terminal_id_ = base::GenerateGUID();
 258   base::win::ScopedBstr terminal_id(base::UTF8ToUTF16(terminal_id_).c_str());
 259   result = rdp_desktop_session_->Connect(host_size.width(), host_size.height(),
 260                                          terminal_id, event_handler.get());
 261   if (FAILED(result)) {
 262     LOG(ERROR) << "RdpSession::Create() failed, 0x"
 263                << std::hex << result << std::dec << ".";
 264     return false;
 265   }
 266
 267   return true;
 268 }
 269
 270 void RdpSession::OnRdpConnected() {
 271   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 272
 273   StopMonitoring();
 274   StartMonitoring(terminal_id_);
 275 }
 276
 277 void RdpSession::OnRdpClosed() {
 278   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 279
 280   TerminateSession();
 281 }
 282
 283 void RdpSession::SetScreenResolution(const ScreenResolution& resolution) {
 284   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 285
 286   // TODO(alexeypa): implement resize-to-client for RDP sessions here.
 287   // See http://crbug.com/137696.
 288   NOTIMPLEMENTED();
 289 }
 290
 291 void RdpSession::InjectSas() {
 292   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 293
 294   rdp_desktop_session_->InjectSas();
 295 }
 296
 297 RdpSession::EventHandler::EventHandler(
 298     base::WeakPtr<RdpSession> desktop_session)
 299     : ref_count_(0),
 300       desktop_session_(desktop_session) {
 301 }
 302
 303 RdpSession::EventHandler::~EventHandler() {
 304   DCHECK(thread_checker_.CalledOnValidThread());
 305
 306   if (desktop_session_)
 307     desktop_session_->OnRdpClosed();
 308 }
 309
 310 ULONG STDMETHODCALLTYPE RdpSession::EventHandler::AddRef() {
 311   DCHECK(thread_checker_.CalledOnValidThread());
 312
 313   return ++ref_count_;
 314 }
 315
 316 ULONG STDMETHODCALLTYPE RdpSession::EventHandler::Release() {
 317   DCHECK(thread_checker_.CalledOnValidThread());
 318
 319   if (--ref_count_ == 0) {
 320     delete this;
 321     return 0;
 322   }
 323
 324   return ref_count_;
 325 }
 326
 327 STDMETHODIMP RdpSession::EventHandler::QueryInterface(REFIID riid, void** ppv) {
 328   DCHECK(thread_checker_.CalledOnValidThread());
 329
 330   if (riid == IID_IUnknown ||
 331       riid == IID_IRdpDesktopSessionEventHandler) {
 332     *ppv = static_cast<IRdpDesktopSessionEventHandler*>(this);
 333     AddRef();
 334     return S_OK;
 335   }
 336
 337   *ppv = nullptr;
 338   return E_NOINTERFACE;
 339 }
 340
 341 STDMETHODIMP RdpSession::EventHandler::OnRdpConnected() {
 342   DCHECK(thread_checker_.CalledOnValidThread());
 343
 344   if (desktop_session_)
 345     desktop_session_->OnRdpConnected();
 346
 347   return S_OK;
 348 }
 349
 350 STDMETHODIMP RdpSession::EventHandler::OnRdpClosed() {
 351   DCHECK(thread_checker_.CalledOnValidThread());
 352
 353   if (!desktop_session_)
 354     return S_OK;
 355
 356   base::WeakPtr<RdpSession> desktop_session = desktop_session_;
 357   desktop_session_.reset();
 358   desktop_session->OnRdpClosed();
 359   return S_OK;
 360 }
 361
 362 } // namespace
 363
 364 // static
 365 scoped_ptr<DesktopSession> DesktopSessionWin::CreateForConsole(
 366     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
 367     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
 368     DaemonProcess* daemon_process,
 369     int id,
 370     const ScreenResolution& resolution) {
 371   scoped_ptr<ConsoleSession> session(new ConsoleSession(
 372       caller_task_runner, io_task_runner, daemon_process, id,
 373       HostService::GetInstance()));
 374
 375   return session.Pass();
 376 }
 377
 378 // static
 379 scoped_ptr<DesktopSession> DesktopSessionWin::CreateForVirtualTerminal(
 380     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
 381     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
 382     DaemonProcess* daemon_process,
 383     int id,
 384     const ScreenResolution& resolution) {
 385   scoped_ptr<RdpSession> session(new RdpSession(
 386       caller_task_runner, io_task_runner, daemon_process, id,
 387       HostService::GetInstance()));
 388   if (!session->Initialize(resolution))
 389     return nullptr;
 390
 391   return session.Pass();
 392 }
 393
 394 DesktopSessionWin::DesktopSessionWin(
 395     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
 396     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
 397     DaemonProcess* daemon_process,
 398     int id,
 399     WtsTerminalMonitor* monitor)
 400     : DesktopSession(daemon_process, id),
 401       caller_task_runner_(caller_task_runner),
 402       io_task_runner_(io_task_runner),
 403       monitor_(monitor),
 404       monitoring_notifications_(false) {
 405   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 406
 407   ReportElapsedTime("created");
 408 }
 409
 410 DesktopSessionWin::~DesktopSessionWin() {
 411   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 412
 413   StopMonitoring();
 414 }
 415
 416 void DesktopSessionWin::OnSessionAttachTimeout() {
 417   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 418
 419   LOG(ERROR) << "Session attach notification didn't arrived within "
 420              << kSessionAttachTimeoutSeconds << " seconds.";
 421   TerminateSession();
 422 }
 423
 424 void DesktopSessionWin::StartMonitoring(const std::string& terminal_id) {
 425   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 426   DCHECK(!monitoring_notifications_);
 427   DCHECK(!session_attach_timer_.IsRunning());
 428
 429   ReportElapsedTime("started monitoring");
 430
 431   session_attach_timer_.Start(
 432       FROM_HERE, base::TimeDelta::FromSeconds(kSessionAttachTimeoutSeconds),
 433       this, &DesktopSessionWin::OnSessionAttachTimeout);
 434
 435   monitoring_notifications_ = true;
 436   monitor_->AddWtsTerminalObserver(terminal_id, this);
 437 }
 438
 439 void DesktopSessionWin::StopMonitoring() {
 440   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 441
 442   if (monitoring_notifications_) {
 443     ReportElapsedTime("stopped monitoring");
 444
 445     monitoring_notifications_ = false;
 446     monitor_->RemoveWtsTerminalObserver(this);
 447   }
 448
 449   session_attach_timer_.Stop();
 450   OnSessionDetached();
 451 }
 452
 453 void DesktopSessionWin::TerminateSession() {
 454   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 455
 456   StopMonitoring();
 457
 458   // This call will delete |this| so it should be at the very end of the method.
 459   daemon_process()->CloseDesktopSession(id());
 460 }
 461
 462 void DesktopSessionWin::OnChannelConnected(int32 peer_pid) {
 463   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 464
 465   ReportElapsedTime("channel connected");
 466
 467   // Obtain the handle of the desktop process. It will be passed to the network
 468   // process to use to duplicate handles of shared memory objects from
 469   // the desktop process.
 470   desktop_process_.Set(OpenProcess(PROCESS_DUP_HANDLE, false, peer_pid));
 471   if (!desktop_process_.IsValid()) {
 472     CrashDesktopProcess(FROM_HERE);
 473     return;
 474   }
 475
 476   VLOG(1) << "IPC: daemon <- desktop (" << peer_pid << ")";
 477 }
 478
 479 bool DesktopSessionWin::OnMessageReceived(const IPC::Message& message) {
 480   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 481
 482   bool handled = true;
 483   IPC_BEGIN_MESSAGE_MAP(DesktopSessionWin, message)
 484     IPC_MESSAGE_HANDLER(ChromotingDesktopDaemonMsg_DesktopAttached,
 485                         OnDesktopSessionAgentAttached)
 486     IPC_MESSAGE_HANDLER(ChromotingDesktopDaemonMsg_InjectSas,
 487                         InjectSas)
 488     IPC_MESSAGE_UNHANDLED(handled = false)
 489   IPC_END_MESSAGE_MAP()
 490
 491   if (!handled) {
 492     LOG(ERROR) << "Received unexpected IPC type: " << message.type();
 493     CrashDesktopProcess(FROM_HERE);
 494   }
 495
 496   return handled;
 497 }
 498
 499 void DesktopSessionWin::OnPermanentError(int exit_code) {
 500   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 501
 502   TerminateSession();
 503 }
 504
 505 void DesktopSessionWin::OnSessionAttached(uint32 session_id) {
 506   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 507   DCHECK(!launcher_);
 508   DCHECK(monitoring_notifications_);
 509
 510   ReportElapsedTime("attached");
 511
 512   // Launch elevated on Win8 to be able to inject Alt+Tab.
 513   bool launch_elevated = base::win::GetVersion() >= base::win::VERSION_WIN8;
 514
 515   // Get the name of the executable to run. |kDesktopBinaryName| specifies
 516   // uiAccess="true" in it's manifest.
 517   base::FilePath desktop_binary;
 518   bool result;
 519   if (launch_elevated) {
 520     result = GetInstalledBinaryPath(kDesktopBinaryName, &desktop_binary);
 521   } else {
 522     result = GetInstalledBinaryPath(kHostBinaryName, &desktop_binary);
 523   }
 524
 525   if (!result) {
 526     TerminateSession();
 527     return;
 528   }
 529
 530   session_attach_timer_.Stop();
 531
 532   scoped_ptr<base::CommandLine> target(new base::CommandLine(desktop_binary));
 533   target->AppendSwitchASCII(kProcessTypeSwitchName, kProcessTypeDesktop);
 534   // Copy the command line switches enabling verbose logging.
 535   target->CopySwitchesFrom(*base::CommandLine::ForCurrentProcess(),
 536                            kCopiedSwitchNames, arraysize(kCopiedSwitchNames));
 537
 538   // Create a delegate capable of launching a process in a different session.
 539   scoped_ptr<WtsSessionProcessDelegate> delegate(
 540       new WtsSessionProcessDelegate(io_task_runner_,
 541                                     target.Pass(),
 542                                     launch_elevated,
 543                                     base::WideToUTF8(
 544                                         kDaemonIpcSecurityDescriptor)));
 545   if (!delegate->Initialize(session_id)) {
 546     TerminateSession();
 547     return;
 548   }
 549
 550   // Create a launcher for the desktop process, using the per-session delegate.
 551   launcher_.reset(new WorkerProcessLauncher(delegate.Pass(), this));
 552 }
 553
 554 void DesktopSessionWin::OnSessionDetached() {
 555   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 556
 557   launcher_.reset();
 558
 559   if (monitoring_notifications_) {
 560     ReportElapsedTime("detached");
 561
 562     session_attach_timer_.Start(
 563         FROM_HERE, base::TimeDelta::FromSeconds(kSessionAttachTimeoutSeconds),
 564         this, &DesktopSessionWin::OnSessionAttachTimeout);
 565   }
 566 }
 567
 568 void DesktopSessionWin::OnDesktopSessionAgentAttached(
 569       IPC::PlatformFileForTransit desktop_pipe) {
 570   if (!daemon_process()->OnDesktopSessionAgentAttached(id(),
 571                                                        desktop_process_.Get(),
 572                                                        desktop_pipe)) {
 573     CrashDesktopProcess(FROM_HERE);
 574   }
 575 }
 576
 577 void DesktopSessionWin::CrashDesktopProcess(
 578     const tracked_objects::Location& location) {
 579   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 580
 581   launcher_->Crash(location);
 582 }
 583
 584 void DesktopSessionWin::ReportElapsedTime(const std::string& event) {
 585   base::Time now = base::Time::Now();
 586
 587   std::string passed;
 588   if (!last_timestamp_.is_null()) {
 589     passed = base::StringPrintf(", %.2fs passed",
 590                                 (now - last_timestamp_).InSecondsF());
 591   }
 592
 593   base::Time::Exploded exploded;
 594   now.LocalExplode(&exploded);
 595   VLOG(1) << base::StringPrintf("session(%d): %s at %02d:%02d:%02d.%03d%s",
 596                                 id(),
 597                                 event.c_str(),
 598                                 exploded.hour,
 599                                 exploded.minute,
 600                                 exploded.second,
 601                                 exploded.millisecond,
 602                                 passed.c_str());
 603
 604   last_timestamp_ = now;
 605 }
 606
 607 }  // namespace remoting