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

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
index ccb141feb205caa6f588268b42701235c0976053..68233fc966754ad251402c8fbe507f176de50fc7 100644
--- a/remoting/host/resizing_host_observer.cc
+++ b/remoting/host/resizing_host_observer.cc
@@ -6,12 +6,17 @@
 
 #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)
@@ -101,7 +106,8 @@ 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() {
@@ -114,17 +120,31 @@ void ResizingHostObserver::SetScreenResolution(
   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;
     }
@@ -132,6 +152,9 @@ void ResizingHostObserver::SetScreenResolution(
   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