Index: remoting/host/resizing_host_observer_unittest.cc |
diff --git a/remoting/host/resizing_host_observer_unittest.cc b/remoting/host/resizing_host_observer_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..92e1863f563b8f7f0e9595722ea54afc543f6416 |
--- /dev/null |
+++ b/remoting/host/resizing_host_observer_unittest.cc |
@@ -0,0 +1,172 @@ |
+// 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 "remoting/host/desktop_resizer.h" |
+ |
+#include <list> |
+ |
+#include "base/compiler_specific.h" |
+#include "base/logging.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+#include "third_party/skia/include/core/SkSize.h" |
+ |
+std::ostream& operator<<(std::ostream& os, const SkISize& size) { |
+ return os << size.width() << "x" << size.height(); |
+} |
+ |
+namespace remoting { |
+ |
+class MockDesktopResizer : public DesktopResizer { |
+ public: |
+ MockDesktopResizer(const SkISize& initial_size, bool exact_size_supported, |
+ const SkISize* supported_sizes, int num_supported_sizes) |
+ : initial_size_(initial_size), |
+ current_size_(initial_size), |
+ exact_size_supported_(exact_size_supported) { |
+ for (int i = 0; i < num_supported_sizes; ++i) { |
+ supported_sizes_.push_back(supported_sizes[i]); |
+ } |
+ } |
+ |
+ const SkISize& initial_size() { return initial_size_; } |
+ |
+ // remoting::DesktopResizer interface |
+ virtual SkISize GetCurrentSize() OVERRIDE { |
+ return current_size_; |
+ } |
+ virtual std::list<SkISize> GetSupportedSizes( |
+ const SkISize& preferred) OVERRIDE { |
+ std::list<SkISize> result = supported_sizes_; |
+ if (exact_size_supported_) { |
+ result.push_back(preferred); |
+ } |
+ return result; |
+ } |
+ virtual void SetSize(const SkISize& size) OVERRIDE { |
+ current_size_ = size; |
+ } |
+ virtual void RestoreSize(const SkISize& size) OVERRIDE { |
+ current_size_ = size; |
+ } |
+ |
+ private: |
+ SkISize initial_size_; |
+ SkISize current_size_; |
+ bool exact_size_supported_; |
+ std::list<SkISize> supported_sizes_; |
+}; |
+ |
+class ResizingHostObserverTest : public testing::Test { |
+ public: |
+ void SetDesktopResizer(MockDesktopResizer* desktop_resizer) { |
+ CHECK(!desktop_resizer_.get()) << "Call SetDeskopResizer once per test"; |
+ resizing_host_observer_.reset(new ResizingHostObserver(desktop_resizer, |
+ NULL)); |
+ desktop_resizer_.reset(desktop_resizer); |
+ resizing_host_observer_->OnClientAuthenticated(""); |
+ } |
+ |
+ SkISize GetBestSize(const SkISize& client_size) { |
+ resizing_host_observer_->OnClientDimensionsChanged("", client_size); |
+ 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]; |
+ } |
+ } |
+ |
+ void Reconnect() { |
+ resizing_host_observer_->OnClientDisconnected(""); |
+ resizing_host_observer_->OnClientAuthenticated(""); |
+ } |
+ |
+ // testing::Test interface |
+ virtual void TearDown() OVERRIDE { |
+ resizing_host_observer_->OnClientDisconnected(""); |
+ EXPECT_EQ(desktop_resizer_->initial_size(), |
+ desktop_resizer_->GetCurrentSize()); |
+ } |
+ |
+ private: |
+ scoped_ptr<ResizingHostObserver> resizing_host_observer_; |
+ scoped_ptr<MockDesktopResizer> desktop_resizer_; |
+}; |
+ |
+// Check that if the implementation supports exact size matching, it is used. |
+TEST_F(ResizingHostObserverTest, SelectExactSize) { |
+ SetDesktopResizer( |
+ new MockDesktopResizer(SkISize::Make(640, 480), true, NULL, 0)); |
+ SkISize client_sizes[] = { { 200, 100 }, { 100, 200 } , { 640, 480 }, |
+ { 480, 640 }, { 1280, 1024 } }; |
+ VerifySizes(client_sizes, client_sizes, arraysize(client_sizes)); |
+} |
+ |
+// Check that if the implementation supports a size that is no larger than |
+// the requested size, then the largest such size is used. |
+TEST_F(ResizingHostObserverTest, SelectBestSmallerSize) { |
+ SkISize supported_sizes[] = { |
+ SkISize::Make(639, 479), SkISize::Make(640, 480) }; |
+ SetDesktopResizer( |
+ new MockDesktopResizer(SkISize::Make(640, 480), false, |
+ supported_sizes, arraysize(supported_sizes))); |
+ SkISize client_sizes[] = { { 639, 479 }, { 640, 480 }, { 641, 481 }, |
+ { 999, 999 } }; |
+ SkISize expected_sizes[] = { supported_sizes[0], supported_sizes[1], |
+ supported_sizes[1], supported_sizes[1] }; |
+ VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
+} |
+ |
+// Check that if the implementation supports only sizes that are larger than |
+// the requested size, then the one that requires the least down-scaling. |
+TEST_F(ResizingHostObserverTest, SelectBestScaleFactor) { |
+ SkISize supported_sizes[] = { |
+ SkISize::Make(100, 100), SkISize::Make(200, 100) }; |
+ SetDesktopResizer( |
+ new MockDesktopResizer(SkISize::Make(200, 100), false, |
+ supported_sizes, arraysize(supported_sizes))); |
+ SkISize client_sizes[] = { { 1, 1 }, { 99, 99 }, { 199, 99 } }; |
+ SkISize expected_sizes[] = { supported_sizes[0], supported_sizes[0], |
+ supported_sizes[1] }; |
+ VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
+} |
+ |
+// Check that if the implementation supports two sizes that have the same |
+// resultant scale factor, then the widest one is selected. |
+TEST_F(ResizingHostObserverTest, SelectWidest) { |
+ SkISize supported_sizes[] = { |
+ SkISize::Make(640, 480), SkISize::Make(480, 640) }; |
+ SetDesktopResizer( |
+ new MockDesktopResizer(SkISize::Make(480, 640), false, |
+ supported_sizes, arraysize(supported_sizes))); |
+ SkISize client_sizes[] = { { 100, 100 }, { 480, 480 }, { 500, 500 }, |
+ { 640, 640 }, { 1000, 1000 } }; |
+ SkISize expected_sizes[] = { supported_sizes[0], supported_sizes[0], |
+ supported_sizes[0], supported_sizes[0], |
+ supported_sizes[0] }; |
+ VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
+} |
+ |
+// Check that resize-to-client is disabled if the size is changed explicitly. |
+TEST_F(ResizingHostObserverTest, ManualResize) { |
Wez
2012/09/25 20:48:29
nit: Add a test for there being no sizes reported
Jamie
2012/09/25 23:20:20
Done.
|
+ MockDesktopResizer* desktop_resizer = |
+ new MockDesktopResizer(SkISize::Make(640, 480), true, NULL, 0); |
+ SetDesktopResizer(desktop_resizer); |
+ SkISize client_sizes[] = { { 1, 1 }, { 2, 2 } , { 3, 3 } }; |
+ VerifySizes(client_sizes, client_sizes, arraysize(client_sizes)); |
+ SkISize explicit_size = SkISize::Make(640, 480); |
+ desktop_resizer->SetSize(explicit_size); |
+ SkISize expected_sizes[] = { explicit_size, explicit_size, explicit_size }; |
+ VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
+ // Make sure this behaviour doesn't persist across reconnect. |
+ Reconnect(); |
+ VerifySizes(client_sizes, client_sizes, arraysize(client_sizes)); |
+} |
+ |
+} // namespace remoting |