Cross-platform plumbing for resize-to-client

remoting/host/resizing_host_observer.cc

Index: remoting/host/resizing_host_observer.cc
diff --git a/remoting/host/resizing_host_observer.cc b/remoting/host/resizing_host_observer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4925792bc2cdcdd2f7fb0e8d80181da0df1fca8a
--- /dev/null
+++ b/remoting/host/resizing_host_observer.cc
@@ -0,0 +1,137 @@
+// 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 "remoting/host/desktop_resizer.h"
+
+#include <set>
+
+#include "base/logging.h"
+
+namespace remoting {
+
+ResizingHostObserver::ResizingHostObserver(
+    DesktopResizer* desktop_resizer)
+    : desktop_resizer_(desktop_resizer),
+      original_size_(SkISize::Make(0, 0)) {
+}
+
+ResizingHostObserver::~ResizingHostObserver() {
+}
+
+void ResizingHostObserver::OnClientAuthenticated(const std::string& jid) {
+  // Resize-to-client doesn't make sense if multiple clients are connected,
+  // and this is not currently supported anyway.
+  DCHECK(client_jid_.empty());
+  original_size_ = desktop_resizer_->GetCurrentSize();
+}
+
+void ResizingHostObserver::OnClientDisconnected(const std::string& jid) {
+  if (!original_size_.isZero()) {
+    desktop_resizer_->SetSize(original_size_);
+    original_size_.set(0, 0);
+  }
+  client_jid_.clear();
+}
+
+class SupportedSize {
+ public:
+  SupportedSize(const SkISize& actual, const SkISize& preferred)
+      : size_(actual) {
+    // The client scale factor is the smaller of the actual:preferred ratios
+    // for width and height.
+    if ((actual.width() > preferred.width()) ||
+        (actual.height() > preferred.height())) {
+      float ratio_width =
+          static_cast<float>(preferred.width()) / actual.width();
+      float ratio_height =
+          static_cast<float>(preferred.height()) / actual.height();
+      client_scale_factor_ = std::min(ratio_width, ratio_height);
+    } else {
+      // Since clients do not scale up, 1.0 is the maximum.

[Wez, 2012/09/21 00:59:32]

nit: up-scale (for consistency w/ use of "down-scale" elsewhere in our code)

+      client_scale_factor_ = 1.0;
+    }
+
+    // The aspect ratio "goodness" is defined as being the ratio of the smaller
+    // of the actual and preferred aspect ratios to the larger. The best aspect
+    // ratio is the one that most closely matches the preferred aspect ratio
+    // (in other words, the ideal aspect ratio "goodness" is 1.0). By keeping
+    // the values < 1.0, it allows ratios the differ in opposite directions to

[Wez, 2012/09/21 00:59:32]

typo: the -> that

+    // be compared numerically.
+    float actual_aspect_ratio =
+        static_cast<float>(actual.width()) / actual.height();
+    float preferred_aspect_ratio =
+        static_cast<float>(preferred.width()) / preferred.height();
+    if (actual_aspect_ratio > preferred_aspect_ratio) {
+      aspect_ratio_goodness_ = preferred_aspect_ratio / actual_aspect_ratio;
+    } else {
+      aspect_ratio_goodness_ = actual_aspect_ratio / preferred_aspect_ratio;
+    }
+  }
+
+  const SkISize& size() const { return size_; }
+  float client_scale_factor() const { return client_scale_factor_; }
+  float aspect_ratio_goodness() const { return aspect_ratio_goodness_; }
+  int64 area() const {
+    return static_cast<int64>(size_.width()) * size_.height();
+  }
+
+  bool IsBetterThan(const SupportedSize& other) const {
+    // If either size would require down-scaling, prefer the one that down-
+    // scales the least (since the client scale factor is at most 1.0, this
+    // does not differentiate between sizes that don't require down-scaling).
+    if (client_scale_factor() < other.client_scale_factor()) {
+      return false;
+    } else if (client_scale_factor() > other.client_scale_factor()) {
+      return true;
+    }
+
+    // If the scale factors are the same, pick the size with the largest area.
+    if (area() < other.area()) {
+      return false;
+    } else if (area() > other.area()) {
+      return true;
+    }
+
+    // If the areas are equal, pick the size with the "best" aspect ratio.
+    if (aspect_ratio_goodness() < other.aspect_ratio_goodness()) {
+      return false;
+    } else if (aspect_ratio_goodness() > other.aspect_ratio_goodness()) {
+      return true;
+    }
+
+    // If the aspect ratios are equally good (for example, comparing 640x480
+    // to 480x640 w.r.t. 640x640), just pick the widest, since desktop UIs
+    // are typically design for landscape aspect ratios.

[Wez, 2012/09/21 00:59:32]

typo: design -> designed

+    return size().width() > other.size().width();
+  }
+
+ private:
+  float client_scale_factor_;
+  float aspect_ratio_goodness_;
+  SkISize size_;
+};
+
+void ResizingHostObserver::OnClientDimensionsChanged(
+    const std::string& jid, const SkISize& preferred_size) {
+  std::list<SkISize> sizes =
+      desktop_resizer_->GetSupportedSizes(preferred_size);
+  if (sizes.empty()) {
+    return;
+  }
+
+  // If the implementation returned any sizes, pick the best one according to
+  // the algorithm described in SupportedSize::IsBetterThen.
+  SupportedSize best_size(sizes.front(), preferred_size);
+  std::list<SkISize>::iterator i = sizes.begin();
+  for (++i; i != sizes.end(); ++i) {
+    SupportedSize candidate_size(*i, preferred_size);
+    if (candidate_size.IsBetterThan(best_size)) {
+      best_size = candidate_size;
+    }
+  }
+  desktop_resizer_->SetSize(best_size.size());
+}
+
+}  // namespace remoting