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

remoting/host/resizing_host_observer.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/resizing_host_observer.h"
 
-#include <set>
+#include <list>
 
 #include "base/logging.h"
 #include "remoting/host/desktop_resizer.h"
-#include "remoting/host/host_status_monitor.h"
 
-namespace remoting {
-
-ResizingHostObserver::ResizingHostObserver(
-    DesktopResizer* desktop_resizer,
-    base::WeakPtr<HostStatusMonitor> monitor)
-    : desktop_resizer_(desktop_resizer),
-      monitor_(monitor),
-      original_size_(SkISize::Make(0, 0)) {
-  monitor_->AddStatusObserver(this);
-}
-
-ResizingHostObserver::~ResizingHostObserver() {
-  if (monitor_)
-    monitor_->RemoveStatusObserver(this);
-}
-
-void ResizingHostObserver::OnClientAuthenticated(const std::string& jid) {
-  // This implementation assumes a single connected client, which is what the
-  // host currently supports
-  DCHECK(client_jid_.empty());
-  original_size_ = desktop_resizer_->GetCurrentSize();
-}
-
-void ResizingHostObserver::OnClientDisconnected(const std::string& jid) {
-  if (!original_size_.isZero()) {
-    desktop_resizer_->RestoreSize(original_size_);
-    original_size_.set(0, 0);
-  }
-  client_jid_.clear();
-}
+namespace {
 
 class CandidateSize {
  public:
   CandidateSize(const SkISize& candidate, const SkISize& preferred)
       : size_(candidate) {
     // Protect against division by zero.
     CHECK(!candidate.isEmpty());
     DCHECK(!preferred.isEmpty());
 
     // The client scale factor is the smaller of the candidate:preferred ratios
@@ skipping 63 matching lines @@
     // are typically designed for landscape aspect ratios.
     return size().width() > other.size().width();
   }
 
  private:
   float client_scale_factor_;
   float aspect_ratio_goodness_;
   SkISize size_;
 };
 
+}  // namespace
+
+namespace remoting {
+
+ResizingHostObserver::ResizingHostObserver(
+    scoped_ptr<DesktopResizer> desktop_resizer)
+    : desktop_resizer_(desktop_resizer.Pass()),
+      original_size_(desktop_resizer_->GetCurrentSize()) {
+}
+
+ResizingHostObserver::~ResizingHostObserver() {
+  if (!original_size_.isZero())
+    desktop_resizer_->RestoreSize(original_size_);
+}
+
 void ResizingHostObserver::OnClientResolutionChanged(
-    const std::string& jid,
-    const SkISize& preferred_size,
-    const SkIPoint& dpi) {
-  if (preferred_size.isEmpty()) {
+    const SkIPoint& client_dpi,
+    const SkISize& client_size) {
+  if (client_size.isEmpty()) {
     return;
   }
 
   // If the implementation returns any sizes, pick the best one according to
   // the algorithm described in CandidateSize::IsBetterThen.
   std::list<SkISize> sizes =
-      desktop_resizer_->GetSupportedSizes(preferred_size);
+      desktop_resizer_->GetSupportedSizes(client_size);
   if (sizes.empty()) {
     return;
   }
-  CandidateSize best_size(sizes.front(), preferred_size);
+  CandidateSize best_size(sizes.front(), client_size);
   for (std::list<SkISize>::const_iterator i = ++sizes.begin();
        i != sizes.end(); ++i) {
-    CandidateSize candidate_size(*i, preferred_size);
+    CandidateSize candidate_size(*i, client_size);
     if (candidate_size.IsBetterThan(best_size)) {
       best_size = candidate_size;
     }
   }
   SkISize current_size = desktop_resizer_->GetCurrentSize();
   if (best_size.size() != current_size)
     desktop_resizer_->SetSize(best_size.size());
 }
 
 }  // namespace remoting