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. Can be overridden
+// for testing.
+const int kDefaultMinimumResizeIntervalMs = 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()),
+      minimum_resize_interval_(
+          base::TimeDelta::FromMilliseconds(kDefaultMinimumResizeIntervalMs)),
+      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_ + minimum_resize_interval_;
+  if (base::Time::Now() < next_allowed_resize) {
+    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();
+}
+
+void ResizingHostObserver::SetMinimumResizeIntervalForTesting(
+    const base::TimeDelta& interval) {
+  minimum_resize_interval_ = interval;
 }
 
 }  // namespace remoting