Aura-Mus: Fix high-DPI gutter

ui/aura/mus/window_tree_client_unittest.cc

 // Copyright 2015 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 "ui/aura/mus/window_tree_client.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 96 matching lines @@
 // WindowTreeClientWmTest with --enable-surface-synchronization.
 class WindowTreeClientWmTestSurfaceSync : public WindowTreeClientWmTest {
  public:
   WindowTreeClientWmTestSurfaceSync() {}
   ~WindowTreeClientWmTestSurfaceSync() override {}
 
   // WindowTreeClientWmTest:
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         cc::switches::kEnableSurfaceSynchronization);
+    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+        switches::kForceDeviceScaleFactor, "2");

[sadrul, 2017/05/09 15:04:59]

This makes all tests run in high-dpi. Can you create a subclass from here for
the gutter test that adds the DSF 2?

Or make all these tests parameterized on DSF ... although that may be going a
bit overboard.

[Fady Samuel, 2017/05/30 21:30:08]

Done.

     WindowTreeClientWmTest::SetUp();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientWmTestSurfaceSync);
 };
 
 // WindowTreeClientWmTest with --force-device-scale-factor=2.
 class WindowTreeClientWmTestHighDPI : public WindowTreeClientWmTest {
  public:
@@ skipping 85 matching lines @@
   // TOP_LEVEL_IN_WM and EMBED_IN_OWNER windows allocate cc::LocalSurfaceIds
   // when their sizes change.
   window.SetProperty(aura::client::kEmbedType,
                      aura::client::WindowEmbedType::EMBED_IN_OWNER);
   window.Init(ui::LAYER_NOT_DRAWN);
 
   // The window will allocate a cc::LocalSurfaceId once it has a bounds.
   WindowMus* window_mus = WindowMus::Get(&window);
   ASSERT_NE(nullptr, window_mus);
   EXPECT_FALSE(window_mus->GetLocalSurfaceId().is_valid());
-  const gfx::Rect new_bounds(gfx::Rect(0, 0, 100, 100));
+  gfx::Rect new_bounds(gfx::Rect(0, 0, 100, 100));
   ASSERT_NE(new_bounds, window.bounds());
   window.SetBounds(new_bounds);
   EXPECT_EQ(new_bounds, window.bounds());
   EXPECT_TRUE(window_mus->GetLocalSurfaceId().is_valid());
 
   // An ClientSurfaceEmbedder isn't created UNTIL the window has a bounds and
   // a valid FrameSinkId.
   WindowPortMus* window_port_mus = WindowPortMus::Get(&window);
   ASSERT_NE(nullptr, window_port_mus);
   EXPECT_EQ(nullptr, window_port_mus->client_surface_embedder());
 
   // Now that the window has a valid FrameSinkId, it can embed the client in a
   // CompositorFrame.
   window_tree_client()->OnFrameSinkIdAllocated(server_id(&window),
                                                cc::FrameSinkId(1, 1));
   ClientSurfaceEmbedder* client_surface_embedder =
       window_port_mus->client_surface_embedder();
   ASSERT_NE(nullptr, client_surface_embedder);
 
   // Until the fallback surface fills the window, we will have gutter.
-  ui::Layer* right_gutter = client_surface_embedder->RightGutterForTesting();
-  ASSERT_NE(nullptr, right_gutter);
-  EXPECT_EQ(gfx::Rect(100, 100), right_gutter->bounds());
-  // We don't have a bottom gutter if the fallback surface size is (0, 0) as the
-  // right gutter will fill the whole area.
-  ASSERT_EQ(nullptr, client_surface_embedder->BottomGutterForTesting());
+  {
+    ui::Layer* right_gutter = client_surface_embedder->RightGutterForTesting();
+    ASSERT_NE(nullptr, right_gutter);
+    EXPECT_EQ(gfx::Rect(100, 100), right_gutter->bounds());
+    // We don't have a bottom gutter if the fallback surface size is (0, 0) as
+    // the right gutter will fill the whole area.
+    ASSERT_EQ(nullptr, client_surface_embedder->BottomGutterForTesting());
+  }
 
   // When a SurfaceInfo arrives from the window server, we use it as the
   // fallback SurfaceInfo. Here we issue the PrimarySurfaceInfo back to the
   // client lib. This should cause the gutter to go away, eliminating overdraw.
   window_tree_client()->OnWindowSurfaceChanged(
       server_id(&window), window_port_mus->PrimarySurfaceInfoForTesting());
 
   // The gutter is gone.
   ASSERT_EQ(nullptr, client_surface_embedder->BottomGutterForTesting());
   ASSERT_EQ(nullptr, client_surface_embedder->RightGutterForTesting());
+
+  // Resize again: we should have gutter.
+  new_bounds.SetRect(0, 0, 150, 150);
+  ASSERT_NE(new_bounds, window.bounds());
+  window.SetBounds(new_bounds);
+  ASSERT_NE(nullptr, client_surface_embedder->BottomGutterForTesting());
+  ASSERT_NE(nullptr, client_surface_embedder->RightGutterForTesting());
+
+  // Until the fallback surface fills the window, we will have gutter.
+  {
+    ui::Layer* right_gutter = client_surface_embedder->RightGutterForTesting();
+    ASSERT_NE(nullptr, right_gutter);
+    EXPECT_EQ(gfx::Rect(100, 0, 50, 150), right_gutter->bounds());
+
+    ui::Layer* bottom_gutter =
+        client_surface_embedder->BottomGutterForTesting();
+    ASSERT_NE(nullptr, bottom_gutter);
+    EXPECT_EQ(gfx::Rect(0, 100, 100, 50), bottom_gutter->bounds());
+  }
 }
 
 // Verifies that the cc::LocalSurfaceId generated by an embedder changes when
 // the size changes, but not when the position changes.
 TEST_F(WindowTreeClientWmTest, SetBoundsLocalSurfaceIdChanges) {
   ASSERT_EQ(base::nullopt, window_tree()->last_local_surface_id());
   Window window(nullptr);
   // TOP_LEVEL_IN_WM and EMBED_IN_OWNER windows allocate cc::LocalSurfaceIds
   // when their sizes change.
   window.SetProperty(aura::client::kEmbedType,
@@ skipping 2135 matching lines @@
             window_tree()->GetEventResult(event_id));
   EXPECT_TRUE(window_delegate1.got_move());
   EXPECT_FALSE(window_delegate2.got_move());
   gfx::Point transformed_event_location_in_dip(event_location_in_dip.x() + 20,
                                                event_location_in_dip.y() + 30);
   EXPECT_EQ(transformed_event_location_in_dip,
             window_delegate1.last_event_location());
 }
 
 }  // namespace aura