resizing_host_observer_unittest.cc revision 2a99a7e74a7f215066514fe81d2bfa6639d9eddd 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <list>
6
7#include "base/compiler_specific.h"
8#include "base/logging.h"
9#include "remoting/host/desktop_resizer.h"
10#include "remoting/host/resizing_host_observer.h"
11#include "remoting/host/screen_resolution.h"
12#include "testing/gtest/include/gtest/gtest.h"
13#include "third_party/skia/include/core/SkSize.h"
14
15std::ostream& operator<<(std::ostream& os, const SkISize& size) {
16  return os << size.width() << "x" << size.height();
17}
18
19const int kDefaultDPI = 96;
20
21namespace remoting {
22
23class FakeDesktopResizer : public DesktopResizer {
24 public:
25  FakeDesktopResizer(const SkISize& initial_size, bool exact_size_supported,
26                     const SkISize* supported_sizes, int num_supported_sizes)
27      : initial_size_(initial_size),
28        current_size_(initial_size),
29        exact_size_supported_(exact_size_supported),
30        set_size_call_count_(0) {
31    for (int i = 0; i < num_supported_sizes; ++i) {
32      supported_sizes_.push_back(supported_sizes[i]);
33    }
34  }
35
36  virtual ~FakeDesktopResizer() {
37    EXPECT_EQ(initial_size_, GetCurrentSize());
38  }
39
40  int set_size_call_count() { return set_size_call_count_; }
41
42  // remoting::DesktopResizer interface
43  virtual SkISize GetCurrentSize() OVERRIDE {
44    return current_size_;
45  }
46  virtual std::list<SkISize> GetSupportedSizes(
47      const SkISize& preferred) OVERRIDE {
48    std::list<SkISize> result = supported_sizes_;
49    if (exact_size_supported_) {
50      result.push_back(preferred);
51    }
52    return result;
53  }
54  virtual void SetSize(const SkISize& size) OVERRIDE {
55    current_size_ = size;
56    ++set_size_call_count_;
57  }
58  virtual void RestoreSize(const SkISize& size) OVERRIDE {
59    current_size_ = size;
60  }
61
62 private:
63  SkISize initial_size_;
64  SkISize current_size_;
65  bool exact_size_supported_;
66  std::list<SkISize> supported_sizes_;
67
68  int set_size_call_count_;
69};
70
71class ResizingHostObserverTest : public testing::Test {
72 public:
73  ResizingHostObserverTest() : desktop_resizer_(NULL) {
74  }
75
76  void SetDesktopResizer(scoped_ptr<FakeDesktopResizer> desktop_resizer) {
77    CHECK(!desktop_resizer_) << "Call SetDeskopResizer once per test";
78    desktop_resizer_ = desktop_resizer.get();
79
80    resizing_host_observer_.reset(
81        new ResizingHostObserver(desktop_resizer.PassAs<DesktopResizer>()));
82  }
83
84  SkISize GetBestSize(const SkISize& client_size) {
85    resizing_host_observer_->SetScreenResolution(ScreenResolution(
86        client_size, SkIPoint::Make(kDefaultDPI, kDefaultDPI)));
87    return desktop_resizer_->GetCurrentSize();
88  }
89
90  void VerifySizes(const SkISize* client_sizes, const SkISize* expected_sizes,
91                   int number_of_sizes) {
92    for (int i = 0; i < number_of_sizes; ++i) {
93      SkISize best_size = GetBestSize(client_sizes[i]);
94      EXPECT_EQ(expected_sizes[i], best_size)
95          << "Input size = " << client_sizes[i];
96    }
97  }
98
99 private:
100  scoped_ptr<ResizingHostObserver> resizing_host_observer_;
101  FakeDesktopResizer* desktop_resizer_;
102};
103
104// Check that the host is not resized if GetSupportedSizes returns an empty
105// list (even if GetCurrentSize is supported).
106TEST_F(ResizingHostObserverTest, EmptyGetSupportedSizes) {
107  SkISize initial = { 640, 480 };
108  scoped_ptr<FakeDesktopResizer> desktop_resizer(
109      new FakeDesktopResizer(initial, false, NULL, 0));
110  SetDesktopResizer(desktop_resizer.Pass());
111
112  SkISize client_sizes[] = { { 200, 100 }, { 100, 200 } };
113  SkISize expected_sizes[] = { initial, initial };
114  VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
115}
116
117// Check that if the implementation supports exact size matching, it is used.
118TEST_F(ResizingHostObserverTest, SelectExactSize) {
119  scoped_ptr<FakeDesktopResizer> desktop_resizer(
120      new FakeDesktopResizer(SkISize::Make(640, 480), true, NULL, 0));
121  SetDesktopResizer(desktop_resizer.Pass());
122
123  SkISize client_sizes[] = { { 200, 100 }, { 100, 200 } , { 640, 480 },
124                             { 480, 640 }, { 1280, 1024 } };
125  VerifySizes(client_sizes, client_sizes, arraysize(client_sizes));
126}
127
128// Check that if the implementation supports a size that is no larger than
129// the requested size, then the largest such size is used.
130TEST_F(ResizingHostObserverTest, SelectBestSmallerSize) {
131  SkISize supported_sizes[] = {
132    SkISize::Make(639, 479), SkISize::Make(640, 480) };
133  scoped_ptr<FakeDesktopResizer> desktop_resizer(
134      new FakeDesktopResizer(SkISize::Make(640, 480), false,
135                             supported_sizes, arraysize(supported_sizes)));
136  SetDesktopResizer(desktop_resizer.Pass());
137
138  SkISize client_sizes[] = { { 639, 479 }, { 640, 480 }, { 641, 481 },
139                             { 999, 999 } };
140  SkISize expected_sizes[] = { supported_sizes[0], supported_sizes[1],
141                               supported_sizes[1], supported_sizes[1] };
142  VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
143}
144
145// Check that if the implementation supports only sizes that are larger than
146// the requested size, then the one that requires the least down-scaling.
147TEST_F(ResizingHostObserverTest, SelectBestScaleFactor) {
148  SkISize supported_sizes[] = { { 100, 100 }, { 200, 100 } };
149  scoped_ptr<FakeDesktopResizer> desktop_resizer(
150      new FakeDesktopResizer(SkISize::Make(200, 100), false,
151                             supported_sizes, arraysize(supported_sizes)));
152  SetDesktopResizer(desktop_resizer.Pass());
153
154  SkISize client_sizes[] = { { 1, 1 }, { 99, 99 }, { 199, 99 } };
155  SkISize expected_sizes[] = { supported_sizes[0], supported_sizes[0],
156                               supported_sizes[1] };
157  VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
158}
159
160// Check that if the implementation supports two sizes that have the same
161// resultant scale factor, then the widest one is selected.
162TEST_F(ResizingHostObserverTest, SelectWidest) {
163  SkISize supported_sizes[] = { { 640, 480 }, { 480, 640 } };
164  scoped_ptr<FakeDesktopResizer> desktop_resizer(
165      new FakeDesktopResizer(SkISize::Make(480, 640), false,
166                             supported_sizes, arraysize(supported_sizes)));
167  SetDesktopResizer(desktop_resizer.Pass());
168
169  SkISize client_sizes[] = { { 100, 100 }, { 480, 480 }, { 500, 500 },
170                             { 640, 640 }, { 1000, 1000 } };
171  SkISize expected_sizes[] = { supported_sizes[0], supported_sizes[0],
172                               supported_sizes[0], supported_sizes[0],
173                               supported_sizes[0] };
174  VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
175}
176
177// Check that if the best match for the client size doesn't change, then we
178// don't call SetSize.
179TEST_F(ResizingHostObserverTest, NoSetSizeForSameSize) {
180  SkISize supported_sizes[] = { { 640, 480 }, { 480, 640 } };
181  FakeDesktopResizer* desktop_resizer =
182      new FakeDesktopResizer(SkISize::Make(640, 480), false,
183                             supported_sizes, arraysize(supported_sizes));
184  SetDesktopResizer(scoped_ptr<FakeDesktopResizer>(desktop_resizer));
185
186  SkISize client_sizes[] = { { 640, 640 }, { 1024, 768 }, { 640, 480 } };
187  SkISize expected_sizes[] = { { 640, 480 }, { 640, 480 }, { 640, 480 } };
188  VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
189  EXPECT_EQ(desktop_resizer->set_size_call_count(), 0);
190}
191
192}  // namespace remoting
193