Add host-side rate-limiting to desktop resize events.

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 <list>
 
+#include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "remoting/host/desktop_resizer.h"
 #include "remoting/host/screen_resolution.h"
 
 namespace {
 
+// Minimum amount of time to wait between desktop resizes.
+const int kMinimumResizeIntervalMs = 1000;
+
 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
     // for width and height.
@@ skipping 69 matching lines @@
   SkISize size_;
 };
 
 }  // namespace
 
 namespace remoting {
 
 ResizingHostObserver::ResizingHostObserver(
     scoped_ptr<DesktopResizer> desktop_resizer)
     : desktop_resizer_(desktop_resizer.Pass()),
-      original_size_(desktop_resizer_->GetCurrentSize()) {
+      original_size_(desktop_resizer_->GetCurrentSize()),
+      weak_factory_(this) {
 }
 
 ResizingHostObserver::~ResizingHostObserver() {
   if (!original_size_.isZero())
     desktop_resizer_->RestoreSize(original_size_);
 }
 
 void ResizingHostObserver::SetScreenResolution(
     const ScreenResolution& resolution) {
   if (resolution.IsEmpty())
     return;
 
+  // Resizing the desktop too often is probably not a good idea, so apply a
+  // simple rate-limiting scheme.
+  base::Time next_allowed_resize =
+      previous_resize_time_ +
+      base::TimeDelta::FromMilliseconds(kMinimumResizeIntervalMs);
+  if (base::Time::Now() < next_allowed_resize) {

[alexeypa (please no reviews), 2013/06/04 17:07:37]

nit: I think |previous_resize_time_| is not really needed too. Instead you can
arm the timer after changing the desktop size. I.e.:

{
if (resolution.IsEmpty() ||
    resolution.dimensions() == desktop_resizer_->GetCurrentSize()) {
  return;
}

...
if (deferred_resize_timer_.IsPending()) {
  deferred_resize_timer_.Start(...);
  return;
}

...
desktop_resizer_->SetSize(best_size.size());

deferred_resize_timer_.Start(current_size);
}

[Jamie, 2013/06/04 21:18:03]

That saves a bit of state, but I think it's less clear, and it relies on
consulting the underlying DesktopResizer in order to detect that a resize has
already happened. In particular, if the desktop resizer hasn't finished
resizing, or if the size has changed again since we set up the timer, it will do
the wrong thing.

+    deferred_resize_timer_.Start(
+        FROM_HERE,
+        next_allowed_resize - base::Time::Now(),
+        base::Bind(&ResizingHostObserver::SetScreenResolution,
+                   weak_factory_.GetWeakPtr(), resolution));
+    return;
+  }
+
   // If the implementation returns any sizes, pick the best one according to
   // the algorithm described in CandidateSize::IsBetterThen.
-  SkISize dimentions = SkISize::Make(
+  SkISize dimensions = SkISize::Make(
       resolution.dimensions().width(), resolution.dimensions().height());
-  std::list<SkISize> sizes = desktop_resizer_->GetSupportedSizes(dimentions);
+  std::list<SkISize> sizes = desktop_resizer_->GetSupportedSizes(dimensions);
   if (sizes.empty())
     return;
-  CandidateSize best_size(sizes.front(), dimentions);
+  CandidateSize best_size(sizes.front(), dimensions);
   for (std::list<SkISize>::const_iterator i = ++sizes.begin();
        i != sizes.end(); ++i) {
-    CandidateSize candidate_size(*i, dimentions);
+    CandidateSize candidate_size(*i, dimensions);
     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());
+
+  // Update the time of last resize to allow it to be rate-limited.
+  previous_resize_time_ = base::Time::Now();
 }
 
 }  // namespace remoting