Don't invoke DesktopResizer::SetSize() if the size isn't changing.

This avoids window flicker on platforms which re-render all windows
when the display settings are set, even if they haven't actually
changed, such as Windows.

This CL incidentally renames MockDesktopResizer to FakeDesktopResizer
in the ResizingHostObserver unit-test implementation.

BUG=157900


Review URL: https://chromiumcodereview.appspot.com/11340002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@165546 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 38 insertions, 20 deletions

diff --git a/remoting/host/resizing_host_observer.cc b/remoting/host/resizing_host_observer.cc
index 27f8abf..039c94d 100644
--- a/remoting/host/resizing_host_observer.cc
+++ b/remoting/host/resizing_host_observer.cc
@@ -135,8 +135,8 @@ void ResizingHostObserver::OnClientDimensionsChanged(
   // If the host desktop size changes other than via the resize-to-client
   // mechanism, then set |previous_size_| to zero and give up. This is an
   // indication that the user doesn't want resize-to-client.
-  SkISize new_size = desktop_resizer_->GetCurrentSize();
-  if (new_size != previous_size_) {
+  SkISize current_size = desktop_resizer_->GetCurrentSize();
+  if (current_size != previous_size_) {
     previous_size_ = SkISize::Make(0, 0);
     return;
   }
@@ -157,7 +157,8 @@ void ResizingHostObserver::OnClientDimensionsChanged(
     }
   }
   previous_size_ = best_size.size();
-  desktop_resizer_->SetSize(previous_size_);
+  if (previous_size_ != current_size)
+    desktop_resizer_->SetSize(previous_size_);
 }
 
 }  // namespace remoting
diff --git a/remoting/host/resizing_host_observer_unittest.cc b/remoting/host/resizing_host_observer_unittest.cc
index 4c5fc3b..5e1d519 100644
--- a/remoting/host/resizing_host_observer_unittest.cc
+++ b/remoting/host/resizing_host_observer_unittest.cc
@@ -18,19 +18,21 @@ std::ostream& operator<<(std::ostream& os, const SkISize& size) {
 
 namespace remoting {
 
-class MockDesktopResizer : public DesktopResizer {
+class FakeDesktopResizer : public DesktopResizer {
  public:
-  MockDesktopResizer(const SkISize& initial_size, bool exact_size_supported,
+  FakeDesktopResizer(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) {
+        exact_size_supported_(exact_size_supported),
+        set_size_call_count_(0) {
     for (int i = 0; i < num_supported_sizes; ++i) {
       supported_sizes_.push_back(supported_sizes[i]);
     }
   }
 
   const SkISize& initial_size() { return initial_size_; }
+  int set_size_call_count() { return set_size_call_count_; }
 
   // remoting::DesktopResizer interface
   virtual SkISize GetCurrentSize() OVERRIDE {
@@ -46,6 +48,7 @@ class MockDesktopResizer : public DesktopResizer {
   }
   virtual void SetSize(const SkISize& size) OVERRIDE {
     current_size_ = size;
+    ++set_size_call_count_;
   }
   virtual void RestoreSize(const SkISize& size) OVERRIDE {
     current_size_ = size;
@@ -56,11 +59,13 @@ class MockDesktopResizer : public DesktopResizer {
   SkISize current_size_;
   bool exact_size_supported_;
   std::list<SkISize> supported_sizes_;
+
+  int set_size_call_count_;
 };
 
 class ResizingHostObserverTest : public testing::Test {
  public:
-  void SetDesktopResizer(MockDesktopResizer* desktop_resizer) {
+  void SetDesktopResizer(FakeDesktopResizer* desktop_resizer) {
     CHECK(!desktop_resizer_.get()) << "Call SetDeskopResizer once per test";
     resizing_host_observer_.reset(new ResizingHostObserver(desktop_resizer,
                                                            NULL));
@@ -96,7 +101,7 @@ class ResizingHostObserverTest : public testing::Test {
 
  private:
   scoped_ptr<ResizingHostObserver> resizing_host_observer_;
-  scoped_ptr<MockDesktopResizer> desktop_resizer_;
+  scoped_ptr<FakeDesktopResizer> desktop_resizer_;
 };
 
 // Check that the host is not resized if it reports an initial size of zero
@@ -104,7 +109,7 @@ class ResizingHostObserverTest : public testing::Test {
 TEST_F(ResizingHostObserverTest, ZeroGetCurrentSize) {
   SkISize zero = { 0, 0 };
   SetDesktopResizer(
-      new MockDesktopResizer(zero, true, NULL, 0));
+      new FakeDesktopResizer(zero, true, NULL, 0));
   SkISize client_sizes[] = { { 200, 100 }, { 100, 200 } };
   SkISize expected_sizes[] = { zero, zero };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
@@ -115,7 +120,7 @@ TEST_F(ResizingHostObserverTest, ZeroGetCurrentSize) {
 TEST_F(ResizingHostObserverTest, EmptyGetSupportedSizes) {
   SkISize initial = { 640, 480 };
   SetDesktopResizer(
-      new MockDesktopResizer(initial, false, NULL, 0));
+      new FakeDesktopResizer(initial, false, NULL, 0));
   SkISize client_sizes[] = { { 200, 100 }, { 100, 200 } };
   SkISize expected_sizes[] = { initial, initial };
   VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes));
@@ -124,7 +129,7 @@ TEST_F(ResizingHostObserverTest, EmptyGetSupportedSizes) {
 // 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));
+      new FakeDesktopResizer(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));
@@ -136,7 +141,7 @@ TEST_F(ResizingHostObserverTest, SelectBestSmallerSize) {
   SkISize supported_sizes[] = {
     SkISize::Make(639, 479), SkISize::Make(640, 480) };
   SetDesktopResizer(
-      new MockDesktopResizer(SkISize::Make(640, 480), false,
+      new FakeDesktopResizer(SkISize::Make(640, 480), false,
                              supported_sizes, arraysize(supported_sizes)));
   SkISize client_sizes[] = { { 639, 479 }, { 640, 480 }, { 641, 481 },
                              { 999, 999 } };
@@ -148,10 +153,9 @@ TEST_F(ResizingHostObserverTest, SelectBestSmallerSize) {
 // 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) };
+  SkISize supported_sizes[] = { { 100, 100 }, { 200, 100 } };
   SetDesktopResizer(
-      new MockDesktopResizer(SkISize::Make(200, 100), false,
+      new FakeDesktopResizer(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],
@@ -162,10 +166,9 @@ TEST_F(ResizingHostObserverTest, SelectBestScaleFactor) {
 // 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) };
+  SkISize supported_sizes[] = { { 640, 480 }, { 480, 640 } };
   SetDesktopResizer(
-      new MockDesktopResizer(SkISize::Make(480, 640), false,
+      new FakeDesktopResizer(SkISize::Make(480, 640), false,
                              supported_sizes, arraysize(supported_sizes)));
   SkISize client_sizes[] = { { 100, 100 }, { 480, 480 }, { 500, 500 },
                              { 640, 640 }, { 1000, 1000 } };
@@ -177,8 +180,8 @@ TEST_F(ResizingHostObserverTest, SelectWidest) {
 
 // Check that resize-to-client is disabled if the size is changed explicitly.
 TEST_F(ResizingHostObserverTest, ManualResize) {
-  MockDesktopResizer* desktop_resizer =
-      new MockDesktopResizer(SkISize::Make(640, 480), true, NULL, 0);
+  FakeDesktopResizer* desktop_resizer =
+      new FakeDesktopResizer(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));
@@ -191,4 +194,18 @@ TEST_F(ResizingHostObserverTest, ManualResize) {
   VerifySizes(client_sizes, client_sizes, arraysize(client_sizes));
 }
 
+// Check that if the best match for the client size doesn't change, then we
+// don't call SetSize.
+TEST_F(ResizingHostObserverTest, NoSetSizeForSameSize) {
+  SkISize supported_sizes[] = { { 640, 480 }, { 480, 640 } };
+  FakeDesktopResizer* desktop_resizer =
+      new FakeDesktopResizer(SkISize::Make(640, 480), false,
+                             supported_sizes, arraysize(supported_sizes));
+  SetDesktopResizer(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);
+}
+
 }  // namespace remoting