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

remoting/host/daemon_process.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/daemon_process.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "net/base/net_util.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_session.h"
 #include "remoting/host/host_event_logger.h"
 #include "remoting/host/host_status_observer.h"
+#include "remoting/host/screen_resolution.h"
 #include "remoting/protocol/transport.h"
 
+namespace remoting {
+
 namespace {
 
-std::ostream& operator<<(std::ostream& os, const SkIPoint& point) {
-  return os << "(" << point.x() << ", " << point.y() << ")";
-}
+// This is used for tagging system event logs.
+const char kApplicationName[] = "chromoting";
 
-std::ostream& operator<<(std::ostream& os, const SkISize& size) {
-  return os << size.width() << "x" << size.height();
+std::ostream& operator<<(std::ostream& os, const ScreenResolution& resolution) {
+  return os << resolution.dimensions_.width() << "x"
+            << resolution.dimensions_.height() << " at "
+            << resolution.dpi_.x() << "x" << resolution.dpi_.y() << " DPI";
 }
 
 }  // namespace
 
-namespace remoting {
-
-// This is used for tagging system event logs.
-const char kApplicationName[] = "chromoting";
-
 DaemonProcess::~DaemonProcess() {
   DCHECK(!config_watcher_.get());
   DCHECK(desktop_sessions_.empty());
 }
 
 void DaemonProcess::OnConfigUpdated(const std::string& serialized_config) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   if (serialized_config_ != serialized_config) {
     serialized_config_ = serialized_config;
@@ skipping 114 matching lines @@
     const base::Closure& stopped_callback)
     : Stoppable(caller_task_runner, stopped_callback),
       caller_task_runner_(caller_task_runner),
       io_task_runner_(io_task_runner),
       next_terminal_id_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(caller_task_runner->BelongsToCurrentThread());
 }
 
 void DaemonProcess::CreateDesktopSession(int terminal_id,
-                                         const DesktopSessionParams& params,
+                                         const ScreenResolution& resolution,
                                          bool virtual_terminal) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   // Validate the supplied terminal ID. An attempt to create a desktop session
   // with an ID that could possibly have been allocated already is considered
   // a protocol error and the network process will be restarted.
   if (IsTerminalIdKnown(terminal_id)) {
     LOG(ERROR) << "An invalid terminal ID. terminal_id=" << terminal_id;
     CrashNetworkProcess(FROM_HERE);
     return;
   }
 
   // Terminal IDs cannot be reused. Update the expected next terminal ID.
   next_terminal_id_ = std::max(next_terminal_id_, terminal_id + 1);
 
-  // Validate |params|.
-  if (params.client_dpi_.x() < 0 || params.client_dpi_.y() < 0) {
-    LOG(ERROR) << "Invalid DPI of the remote screen specified: "
-               << params.client_dpi_;
+  // Validate |resolution|.
+  if (!resolution.IsValid()) {
+    LOG(ERROR) << "Invalid resolution specified: " << resolution;
     SendToNetwork(
         new ChromotingDaemonNetworkMsg_TerminalDisconnected(terminal_id));
     return;
-  }
-  if (params.client_size_.width() < 0 || params.client_size_.height() < 0) {
-    LOG(ERROR) << "Invalid resolution of the remote screen specified: "
-               << params.client_size_;
-    SendToNetwork(
-        new ChromotingDaemonNetworkMsg_TerminalDisconnected(terminal_id));
-    return;
   }
 
   // Create the desktop session.
   scoped_ptr<DesktopSession> session = DoCreateDesktopSession(
-      terminal_id, params, virtual_terminal);
+      terminal_id, resolution, virtual_terminal);
   if (!session) {
     LOG(ERROR) << "Failed to create a desktop session.";
     SendToNetwork(
         new ChromotingDaemonNetworkMsg_TerminalDisconnected(terminal_id));
     return;
   }
 
   VLOG(1) << "Daemon: opened desktop session " << terminal_id;
   desktop_sessions_.push_back(session.release());
 }
@@ skipping 125 matching lines @@
 }
 
 void DaemonProcess::DeleteAllDesktopSessions() {
   while (!desktop_sessions_.empty()) {
     delete desktop_sessions_.front();
     desktop_sessions_.pop_front();
   }
 }
 
 }  // namespace remoting