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

remoting/host/resizing_host_observer_unittest.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 <list>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop.h"
+#include "base/run_loop.h"
 #include "remoting/host/desktop_resizer.h"
 #include "remoting/host/resizing_host_observer.h"
 #include "remoting/host/screen_resolution.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkSize.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 std::ostream& operator<<(std::ostream& os, const SkISize& size) {
   return os << size.width() << "x" << size.height();
 }
@@ skipping 43 matching lines @@
 
  private:
   SkISize initial_size_;
   SkISize current_size_;
   bool exact_size_supported_;
   std::list<SkISize> supported_sizes_;
 
   int set_size_call_count_;
 };
 
+class AutoIncrementNow : public base::RefCountedThreadSafe<AutoIncrementNow> {
+ public:
+  AutoIncrementNow() : now_(base::Time::Now()) {
+  }
+  virtual ~AutoIncrementNow() { }
+
+  base::Time Now() {
+    base::Time result = now_;
+    now_ += base::TimeDelta::FromSeconds(10);
+    return result;
+  }
+
+ private:
+  base::Time now_;
+};
+
 class ResizingHostObserverTest : public testing::Test {
  public:
-  ResizingHostObserverTest() : desktop_resizer_(NULL) {
+  ResizingHostObserverTest()
+      : desktop_resizer_(NULL),
+        now_function_(new AutoIncrementNow) {
   }
 
   void SetDesktopResizer(scoped_ptr<FakeDesktopResizer> desktop_resizer) {
     CHECK(!desktop_resizer_) << "Call SetDeskopResizer once per test";
     desktop_resizer_ = desktop_resizer.get();
 
     resizing_host_observer_.reset(
         new ResizingHostObserver(desktop_resizer.PassAs<DesktopResizer>()));
+    resizing_host_observer_->SetNowFunctionForTesting(
+        base::Bind(&AutoIncrementNow::Now, now_function_));

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

AutoIncrementNow::Now does not need to be in a separate ref-counted class. It
can be method of ResizingHostObserverTest.  ResizingHostObserverTest controls
the lifetime of |resizing_host_observer_|. It also controls when
SetScreenResolution() is called. So it is safe to use base::Unretained here.

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

Done.

   }
 
   SkISize GetBestSize(const SkISize& client_size) {
     resizing_host_observer_->SetScreenResolution(ScreenResolution(
         webrtc::DesktopSize(client_size.width(), client_size.height()),
         webrtc::DesktopVector(kDefaultDPI, kDefaultDPI)));
     return desktop_resizer_->GetCurrentSize();
   }
 
   void VerifySizes(const SkISize* client_sizes, const SkISize* expected_sizes,
                    int number_of_sizes) {
     for (int i = 0; i < number_of_sizes; ++i) {
       SkISize best_size = GetBestSize(client_sizes[i]);
       EXPECT_EQ(expected_sizes[i], best_size)
           << "Input size = " << client_sizes[i];
     }
   }
 
- private:
+ protected:
   scoped_ptr<ResizingHostObserver> resizing_host_observer_;
   FakeDesktopResizer* desktop_resizer_;
+  scoped_refptr<AutoIncrementNow> now_function_;
 };
 
 // Check that the host is not resized if GetSupportedSizes returns an empty
 // list (even if GetCurrentSize is supported).
 TEST_F(ResizingHostObserverTest, EmptyGetSupportedSizes) {
   SkISize initial = { 640, 480 };
   scoped_ptr<FakeDesktopResizer> desktop_resizer(
       new FakeDesktopResizer(initial, false, NULL, 0));
   SetDesktopResizer(desktop_resizer.Pass());
 
@@ skipping 70 matching lines @@
       new FakeDesktopResizer(SkISize::Make(640, 480), false,
                              supported_sizes, arraysize(supported_sizes));
   SetDesktopResizer(scoped_ptr<FakeDesktopResizer>(desktop_resizer));
 
   SkISize client_sizes[] = { { 640, 640 }, { 1024, 768 }, { 640, 480 } };
   SkISize expected_sizes[] = { { 640, 480 }, { 640, 480 }, { 640, 480 } };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
   EXPECT_EQ(desktop_resizer->set_size_call_count(), 0);
 }
 
+class ManualIncrementNow :
+      public base::RefCountedThreadSafe<ManualIncrementNow> {
+ public:
+  ManualIncrementNow() : now_(base::Time::Now()) {
+  }
+  virtual ~ManualIncrementNow() { }
+
+  base::Time Now() {
+    return now_;
+  }
+
+  void Increment(const base::TimeDelta& delta) {
+    now_ += delta;
+  };
+
+ private:
+  base::Time now_;
+};
+
+// Check that desktop resizes are rate-limited, and that if multiple resize
+// requests are received in the time-out period, the most recent is respected.
+TEST_F(ResizingHostObserverTest, RateLimited) {
+  FakeDesktopResizer* desktop_resizer =
+      new FakeDesktopResizer(SkISize::Make(640, 480), true, NULL, 0);
+  SetDesktopResizer(scoped_ptr<FakeDesktopResizer>(desktop_resizer));
+  scoped_refptr<ManualIncrementNow> now_function(new ManualIncrementNow);
+  resizing_host_observer_->SetNowFunctionForTesting(
+      base::Bind(&ManualIncrementNow::Now, now_function));
+
+  base::MessageLoop message_loop;
+  base::RunLoop run_loop;
+
+  EXPECT_EQ(GetBestSize(SkISize::Make(100, 100)), SkISize::Make(100, 100));
+  now_function->Increment(base::TimeDelta::FromMilliseconds(900));
+  EXPECT_EQ(GetBestSize(SkISize::Make(200, 200)), SkISize::Make(100, 100));
+  now_function->Increment(base::TimeDelta::FromMilliseconds(99));
+  EXPECT_EQ(GetBestSize(SkISize::Make(300, 300)), SkISize::Make(100, 100));
+  now_function->Increment(base::TimeDelta::FromMilliseconds(1));

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

nit: remove this line.

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

It's needed, otherwise when the delayed resize happens, it will get the wrong
time and think it needs to be delayed again.

+
+  // The most recent resize was requested 999ms after the first, so it should
+  // be processed within 1ms.

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

Mention that |kDefaultMinimumResizeIntervalMs| must be kept in sync with this
test.

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

Done.

+  message_loop.PostDelayedTask(
+      FROM_HERE,
+      run_loop.QuitClosure(),
+      base::TimeDelta::FromMilliseconds(1));

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

nit: Make it 2ms

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

Done.

+  run_loop.Run();
+
+  EXPECT_EQ(desktop_resizer_->GetCurrentSize(), SkISize::Make(300, 300));
+}
+
 }  // namespace remoting