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

remoting/host/client_session.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/client_session.h"
 
 #include <algorithm>
 
 #include "base/message_loop_proxy.h"
 #include "media/video/capture/screen/screen_capturer.h"
 #include "remoting/codec/audio_encoder.h"
 #include "remoting/codec/audio_encoder_opus.h"
 #include "remoting/codec/audio_encoder_speex.h"
 #include "remoting/codec/audio_encoder_verbatim.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/codec/video_encoder_vp8.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/audio_scheduler.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
+#include "remoting/host/screen_resolution.h"
 #include "remoting/host/session_controller.h"
 #include "remoting/host/video_scheduler.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_thread_proxy.h"
 
-namespace remoting {
-
-namespace {
 // Default DPI to assume for old clients that use notifyClientDimensions.
 const int kDefaultDPI = 96;
-} // namespace
+
+namespace remoting {
 
 ClientSession::ClientSession(
     EventHandler* event_handler,
     scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     scoped_ptr<protocol::ConnectionToClient> connection,
@@ skipping 44 matching lines @@
   DCHECK(!audio_scheduler_);
   DCHECK(!event_executor_);
   DCHECK(!session_controller_);
   DCHECK(!video_scheduler_);
 
   connection_.reset();
 }
 
 void ClientSession::NotifyClientResolution(
     const protocol::ClientResolution& resolution) {
-  if (resolution.has_dips_width() && resolution.has_dips_height()) {
-    VLOG(1) << "Received ClientResolution (dips_width="
-            << resolution.dips_width() << ", dips_height="
-            << resolution.dips_height() << ")";
-    if (session_controller_) {
-      session_controller_->OnClientResolutionChanged(
-          SkIPoint::Make(kDefaultDPI, kDefaultDPI),
-          SkISize::Make(resolution.dips_width(), resolution.dips_height()));
-    }
-  }
+  if (!resolution.has_dips_width() || !resolution.has_dips_height())
+    return;
+
+  VLOG(1) << "Received ClientResolution (dips_width="
+          << resolution.dips_width() << ", dips_height="
+          << resolution.dips_height() << ")";
+
+  if (!session_controller_)
+    return;
+
+  ScreenResolution client_resolution(
+      SkISize::Make(resolution.dips_width(), resolution.dips_height()),
+      SkIPoint::Make(kDefaultDPI, kDefaultDPI));
+
+  // Try to match the client's resolution.
+  if (client_resolution.IsValid())
+    session_controller_->SetScreenResolution(client_resolution);
 }
 
 void ClientSession::ControlVideo(const protocol::VideoControl& video_control) {
   if (video_control.has_enable()) {
     VLOG(1) << "Received VideoControl (enable="
             << video_control.enable() << ")";
     if (video_scheduler_)
       video_scheduler_->Pause(!video_control.enable());
   }
 }
@@ skipping 212 matching lines @@
     return scoped_ptr<AudioEncoder>(new AudioEncoderSpeex());
   } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
     return scoped_ptr<AudioEncoder>(new AudioEncoderOpus());
   }
 
   NOTIMPLEMENTED();
   return scoped_ptr<AudioEncoder>(NULL);
 }
 
 }  // namespace remoting