Reworked the plumbing required to pass the client resolution to the desktop resizer.

remoting/host/desktop_session_win.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/desktop_session_win.h"
 
 #include <limits>
 #include <sddl.h>
 
 #include "base/base_switches.h"
@@ skipping 13 matching lines @@
 #include "net/base/ip_endpoint.h"
 #include "remoting/base/auto_thread_task_runner.h"
 // MIDL-generated declarations and definitions.
 #include "remoting/host/chromoting_lib.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/daemon_process.h"
 #include "remoting/host/desktop_session.h"
 #include "remoting/host/host_main.h"
 #include "remoting/host/ipc_constants.h"
 #include "remoting/host/sas_injector.h"
+#include "remoting/host/screen_resolution.h"
 #include "remoting/host/win/host_service.h"
 #include "remoting/host/win/worker_process_launcher.h"
 #include "remoting/host/win/wts_session_process_delegate.h"
 #include "remoting/host/win/wts_terminal_monitor.h"
 #include "remoting/host/win/wts_terminal_observer.h"
 #include "remoting/host/worker_process_ipc_delegate.h"
 
 using base::win::ScopedHandle;
 
 namespace remoting {
@@ skipping 14 matching lines @@
 const char* kCopiedSwitchNames[] = { switches::kV, switches::kVModule };
 
 // RDC 6.1 (W2K8) supports dimensions of up to 4096x2048.
 const int kMaxRdpScreenWidth = 4096;
 const int kMaxRdpScreenHeight = 2048;
 
 // The minimum effective screen dimensions supported by Windows are 800x600.
 const int kMinRdpScreenWidth = 800;
 const int kMinRdpScreenHeight = 600;
 
-// Default dots per inch is 96 DPI.
-const int kDefaultDpiX = 96;
-const int kDefaultDpiY = 96;
+// Default dots per inch used by RDP is 96 DPI.
+const int kDefaultRdpDpi = 96;
 
 // The session attach notification should arrive within 30 seconds.
 const int kSessionAttachTimeoutSeconds = 30;
 
 // DesktopSession implementation which attaches to the host's physical console.
 // Receives IPC messages from the desktop process, running in the console
 // session, via |WorkerProcessIpcDelegate|, and monitors console session
 // attach/detach events via |WtsConsoleObserer|.
 class ConsoleSession : public DesktopSessionWin {
  public:
@@ skipping 25 matching lines @@
   // Same as DesktopSessionWin().
   RdpSession(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
     WtsTerminalMonitor* monitor);
   virtual ~RdpSession();
 
   // Performs the part of initialization that can fail.
-  bool Initialize(const DesktopSessionParams& params);
+  bool Initialize(const ScreenResolution& resolution);
 
   // Mirrors IRdpDesktopSessionEventHandler.
   void OnRdpConnected(const net::IPEndPoint& client_endpoint);
   void OnRdpClosed();
 
  protected:
   // DesktopSessionWin overrides.
   virtual void InjectSas() OVERRIDE;
 
  private:
@@ skipping 61 matching lines @@
     int id,
     WtsTerminalMonitor* monitor)
     : DesktopSessionWin(caller_task_runner, io_task_runner, daemon_process, id,
                         monitor),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 RdpSession::~RdpSession() {
 }
 
-bool RdpSession::Initialize(const DesktopSessionParams& params) {
+bool RdpSession::Initialize(const ScreenResolution& resolution) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   // Create the RDP wrapper object.
   HRESULT result = rdp_desktop_session_.CreateInstance(
       __uuidof(RdpDesktopSession));
   if (FAILED(result)) {
     LOG(ERROR) << "Failed to create RdpSession object, 0x"
                << std::hex << result << std::dec << ".";
     return false;
   }
 
-  // DaemonProcess::CreateDesktopSession() varifies that |client_dpi_| and
-  // |client_size_| are positive.
-  DCHECK(params.client_dpi_.x() >= 0 && params.client_dpi_.y() >= 0);
-  DCHECK(params.client_size_.width() >= 0 && params.client_size_.height() >= 0);
+  // DaemonProcess::CreateDesktopSession() verifies that the resolution is
+  // valid.
+  DCHECK(resolution.IsValid());
 
-  // Handle the default DPI.
-  SkIPoint client_dpi = params.client_dpi_;
-  if (!client_dpi.x())
-    client_dpi.setX(kDefaultDpiX);
-  if (!client_dpi.y())
-    client_dpi.setY(kDefaultDpiY);
-
-  // Make sure there will be no integer overflow while scaling the client
-  // resolution.
-  SkISize client_size = SkISize::Make(
-      std::min(params.client_size_.width(),
-               std::numeric_limits<int32_t>::max() / kDefaultDpiX),
-      std::min(params.client_size_.height(),
-               std::numeric_limits<int32_t>::max() / kDefaultDpiY));
-
-  // Scale the client resolution assiming RDP gives us the default 96 DPI.
-  SkISize host_size = SkISize::Make(
-      client_size.width() * kDefaultDpiX / client_dpi.x(),
-      client_size.height() * kDefaultDpiY / client_dpi.y());
+  // Get the screen dimensions assuming the default DPI.
+  SkISize host_size = resolution.ScaleDimensionsToDpi(
+      SkIPoint::Make(kDefaultRdpDpi, kDefaultRdpDpi));
 
   // Make sure that the host resolution is within the limits supported by RDP.
   host_size = SkISize::Make(
       std::min(kMaxRdpScreenWidth,
                std::max(kMinRdpScreenWidth, host_size.width())),
       std::min(kMaxRdpScreenHeight,
                std::max(kMinRdpScreenHeight, host_size.height())));
 
   // Create an RDP session.
   base::win::ScopedComPtr<IRdpDesktopSessionEventHandler> event_handler(
@@ skipping 106 matching lines @@
 }
 
 } // namespace
 
 // static
 scoped_ptr<DesktopSession> DesktopSessionWin::CreateForConsole(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
-    const DesktopSessionParams& params) {
+    const ScreenResolution& resolution) {
   scoped_ptr<ConsoleSession> session(new ConsoleSession(
       caller_task_runner, io_task_runner, daemon_process, id,
       HostService::GetInstance()));
 
   return session.PassAs<DesktopSession>();
 }
 
 // static
 scoped_ptr<DesktopSession> DesktopSessionWin::CreateForVirtualTerminal(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
-    const DesktopSessionParams& params) {
+    const ScreenResolution& resolution) {
   scoped_ptr<RdpSession> session(new RdpSession(
       caller_task_runner, io_task_runner, daemon_process, id,
       HostService::GetInstance()));
-  if (!session->Initialize(params))
+  if (!session->Initialize(resolution))
     return scoped_ptr<DesktopSession>();
 
   return session.PassAs<DesktopSession>();
 }
 
 DesktopSessionWin::DesktopSessionWin(
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner,
     DaemonProcess* daemon_process,
     int id,
@@ skipping 144 matching lines @@
 }
 
 void DesktopSessionWin::CrashDesktopProcess(
     const tracked_objects::Location& location) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   launcher_->Crash(location);
 }
 
 }  // namespace remoting