ResizingHostObserver is created by the desktop environment together with other stubs.

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/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.
@@ skipping 55 matching lines @@
   remote_input_filter_.SetExpectLocalEcho(false);
 #endif  // defined(OS_WIN)
 }
 
 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() << ")";
-    event_handler_->OnClientResolutionChanged(
-        this,
-        SkISize::Make(resolution.dips_width(), resolution.dips_height()),
-        SkIPoint::Make(kDefaultDPI, kDefaultDPI));
+    session_controller_->OnClientResolutionChanged(
+        SkIPoint::Make(kDefaultDPI, kDefaultDPI),
+        SkISize::Make(resolution.dips_width(), resolution.dips_height()));
   }
 }
 
 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 28 matching lines @@
 
   event_handler_->OnSessionAuthenticated(this);
 }
 
 void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
   DCHECK(!audio_scheduler_);
   DCHECK(!event_executor_);
+  DCHECK(!session_controller_);
   DCHECK(!video_scheduler_);
 
+  // Create the session controller.
+  session_controller_ = desktop_environment_->CreateSessionController();
+
   // Create and start the event executor.
   event_executor_ = desktop_environment_->CreateEventExecutor(
       input_task_runner_, ui_task_runner_);
   event_executor_->Start(CreateClipboardProxy());
 
   // Connect the host clipboard and input stubs.
   host_input_filter_.set_input_stub(event_executor_.get());
   clipboard_echo_filter_.set_host_stub(event_executor_.get());
 
   SetDisableInputs(false);
@@ skipping 57 matching lines @@
     audio_scheduler_->Stop();
     audio_scheduler_ = NULL;
   }
   if (video_scheduler_) {
     video_scheduler_->Stop();
     video_scheduler_ = NULL;
   }
 
   client_clipboard_factory_.InvalidateWeakPtrs();
   event_executor_.reset();
+  session_controller_.reset();
 
   // Notify the ChromotingHost that this client is disconnected.
   // TODO(sergeyu): Log failure reason?
   event_handler_->OnSessionClosed(this);
 }
 
 void ClientSession::OnSequenceNumberUpdated(
     protocol::ConnectionToClient* connection, int64 sequence_number) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
@@ skipping 21 matching lines @@
 
   // This triggers OnConnectionClosed(), and the session may be destroyed
   // as the result, so this call must be the last in this method.
   connection_->Disconnect();
 }
 
 void ClientSession::Stop() {
   DCHECK(CalledOnValidThread());
   DCHECK(!audio_scheduler_);
   DCHECK(!event_executor_);
+  DCHECK(!session_controller_);
   DCHECK(!video_scheduler_);
 
   connection_.reset();
 }
 
 void ClientSession::LocalMouseMoved(const SkIPoint& mouse_pos) {
   DCHECK(CalledOnValidThread());
   remote_input_filter_.LocalMouseMoved(mouse_pos);
 }
 
 void ClientSession::SetDisableInputs(bool disable_inputs) {
   DCHECK(CalledOnValidThread());
 
   if (disable_inputs)
     input_tracker_.ReleaseAll();
 
   disable_input_filter_.set_enabled(!disable_inputs);
   disable_clipboard_filter_.set_enabled(!disable_inputs);
 }
 
 ClientSession::~ClientSession() {
   DCHECK(CalledOnValidThread());
   DCHECK(!audio_scheduler_);
   DCHECK(!event_executor_);
+  DCHECK(!session_controller_);
   DCHECK(!video_scheduler_);
 }
 
 scoped_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
   DCHECK(CalledOnValidThread());
 
   return scoped_ptr<protocol::ClipboardStub>(
       new protocol::ClipboardThreadProxy(
           client_clipboard_factory_.GetWeakPtr(),
           base::MessageLoopProxy::current()));
@@ skipping 31 matching lines @@
   NOTIMPLEMENTED();
   return scoped_ptr<AudioEncoder>(NULL);
 }
 
 // static
 void ClientSessionTraits::Destruct(const ClientSession* client) {
   client->network_task_runner_->DeleteSoon(FROM_HERE, client);
 }
 
 }  // namespace remoting