remoting/host/resizing_host_observer.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/host/resizing_host_observer.h"
   6
   7 #include <list>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "remoting/host/desktop_resizer.h"
  13 #include "remoting/host/screen_resolution.h"
  14
  15 namespace remoting {
  16 namespace {
  17
  18 // Minimum amount of time to wait between desktop resizes. Note that this
  19 // constant is duplicated by the ResizingHostObserverTest.RateLimited
  20 // unit-test and must be kept in sync.
  21 const int kMinimumResizeIntervalMs = 1000;
  22
  23 class CandidateResolution {
  24  public:
  25   CandidateResolution(const ScreenResolution& candidate,
  26                       const ScreenResolution& preferred)
  27       : resolution_(candidate) {
  28     // Protect against division by zero.
  29     CHECK(!candidate.IsEmpty());
  30     DCHECK(!preferred.IsEmpty());
  31
  32     // The client scale factor is the smaller of the candidate:preferred ratios
  33     // for width and height.
  34     if ((candidate.dimensions().width() > preferred.dimensions().width()) ||
  35         (candidate.dimensions().height() > preferred.dimensions().height())) {
  36       const float width_ratio =
  37           static_cast<float>(preferred.dimensions().width()) /
  38           candidate.dimensions().width();
  39       const float height_ratio =
  40           static_cast<float>(preferred.dimensions().height()) /
  41           candidate.dimensions().height();
  42       client_scale_factor_ = std::min(width_ratio, height_ratio);
  43     } else {
  44       // Since clients do not scale up, 1.0 is the maximum.
  45       client_scale_factor_ = 1.0;
  46     }
  47
  48     // The aspect ratio "goodness" is defined as being the ratio of the smaller
  49     // of the two aspect ratios (candidate and preferred) to the larger. The
  50     // best aspect ratio is the one that most closely matches the preferred
  51     // aspect ratio (in other words, the ideal aspect ratio "goodness" is 1.0).
  52     // By keeping the values < 1.0, it allows ratios that differ in opposite
  53     // directions to be compared numerically.
  54     float candidate_aspect_ratio =
  55         static_cast<float>(candidate.dimensions().width()) /
  56         candidate.dimensions().height();
  57     float preferred_aspect_ratio =
  58         static_cast<float>(preferred.dimensions().width()) /
  59         preferred.dimensions().height();
  60     if (candidate_aspect_ratio > preferred_aspect_ratio) {
  61       aspect_ratio_goodness_ = preferred_aspect_ratio / candidate_aspect_ratio;
  62     } else {
  63       aspect_ratio_goodness_ = candidate_aspect_ratio / preferred_aspect_ratio;
  64     }
  65   }
  66
  67   const ScreenResolution& resolution() const { return resolution_; }
  68   float client_scale_factor() const { return client_scale_factor_; }
  69   float aspect_ratio_goodness() const { return aspect_ratio_goodness_; }
  70   int64 area() const {
  71     return static_cast<int64>(resolution_.dimensions().width()) *
  72         resolution_.dimensions().height();
  73   }
  74
  75   // TODO(jamiewalch): Also compare the DPI: http://crbug.com/172405
  76   bool IsBetterThan(const CandidateResolution& other) const {
  77     // If either resolution would require down-scaling, prefer the one that
  78     // down-scales the least (since the client scale factor is at most 1.0,
  79     // this does not differentiate between resolutions that don't require
  80     // down-scaling).
  81     if (client_scale_factor() < other.client_scale_factor()) {
  82       return false;
  83     } else if (client_scale_factor() > other.client_scale_factor()) {
  84       return true;
  85     }
  86
  87     // If the scale factors are the same, pick the resolution with the largest
  88     // area.
  89     if (area() < other.area()) {
  90       return false;
  91     } else if (area() > other.area()) {
  92       return true;
  93     }
  94
  95     // If the areas are equal, pick the resolution with the "best" aspect ratio.
  96     if (aspect_ratio_goodness() < other.aspect_ratio_goodness()) {
  97       return false;
  98     } else if (aspect_ratio_goodness() > other.aspect_ratio_goodness()) {
  99       return true;
 100     }
 101
 102     // All else being equal (for example, comparing 640x480 to 480x640 w.r.t.
 103     // 640x640), just pick the widest, since desktop UIs are typically designed
 104     // for landscape aspect ratios.
 105     return resolution().dimensions().width() >
 106         other.resolution().dimensions().width();
 107   }
 108
 109  private:
 110   float client_scale_factor_;
 111   float aspect_ratio_goodness_;
 112   ScreenResolution resolution_;
 113 };
 114
 115 }  // namespace
 116
 117 ResizingHostObserver::ResizingHostObserver(
 118     scoped_ptr<DesktopResizer> desktop_resizer)
 119     : desktop_resizer_(desktop_resizer.Pass()),
 120       now_function_(base::Bind(base::Time::Now)),
 121       weak_factory_(this) {
 122 }
 123
 124 ResizingHostObserver::~ResizingHostObserver() {
 125   if (!original_resolution_.IsEmpty())
 126     desktop_resizer_->RestoreResolution(original_resolution_);
 127 }
 128
 129 void ResizingHostObserver::SetScreenResolution(
 130     const ScreenResolution& resolution) {
 131   // Get the current time. This function is called exactly once for each call
 132   // to SetScreenResolution to simplify the implementation of unit-tests.
 133   base::Time now = now_function_.Run();
 134
 135   if (resolution.IsEmpty())
 136     return;
 137
 138   // Resizing the desktop too often is probably not a good idea, so apply a
 139   // simple rate-limiting scheme.
 140   base::TimeDelta minimum_resize_interval =
 141       base::TimeDelta::FromMilliseconds(kMinimumResizeIntervalMs);
 142   base::Time next_allowed_resize =
 143       previous_resize_time_ + minimum_resize_interval;
 144
 145   if (now < next_allowed_resize) {
 146     deferred_resize_timer_.Start(
 147         FROM_HERE,
 148         next_allowed_resize - now,
 149         base::Bind(&ResizingHostObserver::SetScreenResolution,
 150                    weak_factory_.GetWeakPtr(), resolution));
 151     return;
 152   }
 153
 154   // If the implementation returns any resolutions, pick the best one according
 155   // to the algorithm described in CandidateResolution::IsBetterThen.
 156   std::list<ScreenResolution> resolutions =
 157       desktop_resizer_->GetSupportedResolutions(resolution);
 158   if (resolutions.empty())
 159     return;
 160   CandidateResolution best_candidate(resolutions.front(), resolution);
 161   for (std::list<ScreenResolution>::const_iterator i = ++resolutions.begin();
 162        i != resolutions.end(); ++i) {
 163     CandidateResolution candidate(*i, resolution);
 164     if (candidate.IsBetterThan(best_candidate)) {
 165       best_candidate = candidate;
 166     }
 167   }
 168   ScreenResolution current_resolution =
 169       desktop_resizer_->GetCurrentResolution();
 170
 171   if (!best_candidate.resolution().Equals(current_resolution)) {
 172     if (original_resolution_.IsEmpty())
 173       original_resolution_ = current_resolution;
 174     desktop_resizer_->SetResolution(best_candidate.resolution());
 175   }
 176
 177   // Update the time of last resize to allow it to be rate-limited.
 178   previous_resize_time_ = now;
 179 }
 180
 181 void ResizingHostObserver::SetNowFunctionForTesting(
 182     const base::Callback<base::Time(void)>& now_function) {
 183   now_function_ = now_function;
 184 }
 185
 186 }  // namespace remoting