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 {
 
 class CandidateSize {
  public:
   CandidateSize(const SkISize& candidate, const SkISize& preferred)
       : size_(candidate) {
     // Protect against division by zero.
@@ skipping 74 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()),
+      now_function_(base::Bind(base::Time::Now)),
+      weak_factory_(this) {
 }
 
 ResizingHostObserver::~ResizingHostObserver() {
   if (!original_size_.isZero())
     desktop_resizer_->RestoreSize(original_size_);
 }
 
 void ResizingHostObserver::SetScreenResolution(
     const ScreenResolution& resolution) {
+  // Get the current time. This function is called exactly once for each call
+  // to SetScreenResolution to simplify the implementation of unit-tests.
+  base::Time now = now_function_.Run();
+
   if (resolution.IsEmpty())
     return;
 
+  // Resizing the desktop too often is probably not a good idea, so apply a
+  // simple rate-limiting scheme.
+  base::TimeDelta minimum_resize_interval = base::TimeDelta::FromSeconds(1);

[alexeypa (please no reviews), 2013/06/07 19:50:25]

I think it was better with kDefaultMinimumResizeIntervalMs constant. It makes it
easy to find and tweak the timeout value if needed.

Also mention next to the constant declaration that it must be kept in sync with
ResizingHostObserverTest.RateLimited.

[Jamie, 2013/06/07 20:20:14]

Done (without the Default, since it can't be overridden any more).
Done (although the consequences of failing to do so would be a unit test
failure, so I'd hope it would be pretty obvious).

+  base::Time next_allowed_resize =
+      previous_resize_time_ + minimum_resize_interval;
+
+  if (now < next_allowed_resize) {
+    deferred_resize_timer_.Start(
+        FROM_HERE,
+        next_allowed_resize - 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_ = now;
+}
+
+void ResizingHostObserver::SetNowFunctionForTesting(
+    const base::Callback<base::Time(void)>& now_function) {
+  now_function_ = now_function;
 }
 
 }  // namespace remoting