Aura-Mus: Implement gutter in the embedder.

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"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "cc/base/switches.h"
 #include "cc/surfaces/surface_info.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/capture_client_observer.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/capture_synchronizer.h"
+#include "ui/aura/mus/client_surface_embedder.h"
 #include "ui/aura/mus/focus_synchronizer.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/test/aura_mus_test_base.h"
 #include "ui/aura/test/mus/test_window_tree.h"
 #include "ui/aura/test/mus/window_tree_client_private.h"
@@ skipping 58 matching lines @@
 // Note that this implicitly casts arguments to the aura storage type, int64_t.
 std::vector<uint8_t> ConvertToPropertyTransportValue(int64_t value) {
   return mojo::ConvertTo<std::vector<uint8_t>>(value);
 }
 
 }  // namespace
 
 using WindowTreeClientWmTest = test::AuraMusWmTestBase;
 using WindowTreeClientClientTest = test::AuraMusClientTestBase;
 
+// WindowTreeClientWmTest with --enable-surface-synchronization.
+class WindowTreeClientWmTestSurfaceSync : public WindowTreeClientWmTest {
+ public:
+  WindowTreeClientWmTestSurfaceSync() {}
+  ~WindowTreeClientWmTestSurfaceSync() override {}
+
+  // WindowTreeClientWmTest:
+  void SetUp() override {
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        cc::switches::kEnableSurfaceSynchronization);
+    WindowTreeClientWmTest::SetUp();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WindowTreeClientWmTestSurfaceSync);
+};
+
 // WindowTreeClientWmTest with --force-device-scale-factor=2.
 class WindowTreeClientWmTestHighDPI : public WindowTreeClientWmTest {
  public:
   WindowTreeClientWmTestHighDPI() {}
   ~WindowTreeClientWmTestHighDPI() override {}
 
   // WindowTreeClientWmTest:
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kForceDeviceScaleFactor, "2");
@@ skipping 23 matching lines @@
   void OnPointerEventObserved(const ui::PointerEvent& event,
                               Window* target) override {
     last_event_observed_.reset(new ui::PointerEvent(event));
   }
 
  private:
   std::unique_ptr<ui::PointerEvent> last_event_observed_;
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientClientTestHighDPI);
 };
 
-// Verifies that a ClientSurfaceEmbedder will only be allocated if a window
-// is visible that embeds a WindowTreeClient.
-TEST_F(WindowTreeClientWmTest, ClientSurfaceEmbedderIfVisible) {
-  Window window(nullptr);
-  // 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);
-
-  WindowMus* window_mus = WindowMus::Get(&window);
-  const cc::SurfaceId surface_id(
-      cc::FrameSinkId(1, 1),
-      cc::LocalSurfaceId(1, base::UnguessableToken::Create()));
-  constexpr float device_scale_factor = 1.f;
-  constexpr gfx::Size size(100, 100);
-
-  window_mus->SetPrimarySurfaceInfo(
-      cc::SurfaceInfo(surface_id, device_scale_factor, size));
-
-  WindowPortMus* window_port_mus = WindowPortMus::Get(&window);
-  ASSERT_NE(nullptr, window_port_mus);
-  EXPECT_EQ(nullptr, window_port_mus->client_surface_embedder());
-
-  // Showing the window results in the creation of a ClientSurfaceEmbedder.
-  window.Show();
-  EXPECT_NE(nullptr, window_port_mus->client_surface_embedder());
-
-  // Hiding it again removes the ClientSurfaceEmbedder.
-  window.Hide();
-  EXPECT_EQ(nullptr, window_port_mus->client_surface_embedder());
-
-  // Setting an invalid cc::SurfaceInfo also eliminates the
-  // ClientSurfaceEmbedder.
-  window.Show();
-  EXPECT_NE(nullptr, window_port_mus->client_surface_embedder());
-  window_mus->SetPrimarySurfaceInfo(cc::SurfaceInfo());
-  EXPECT_EQ(nullptr, window_port_mus->client_surface_embedder());
-}
-
 // Verifies bounds are reverted if the server replied that the change failed.
 TEST_F(WindowTreeClientWmTest, SetBoundsFailed) {
   Window window(nullptr);
   window.Init(ui::LAYER_NOT_DRAWN);
   const gfx::Rect original_bounds(window.bounds());
   const 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());
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(WindowTreeChangeType::BOUNDS,
@@ skipping 21 matching lines @@
   EXPECT_TRUE(window_mus->GetLocalSurfaceId().is_valid());
 
   // Reverting the change should also revert the cc::LocalSurfaceId.
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(WindowTreeChangeType::BOUNDS,
                                                    false));
   EXPECT_EQ(original_bounds, window.bounds());
   EXPECT_FALSE(window_mus->GetLocalSurfaceId().is_valid());
 }
 
 // Verifies that a ClientSurfaceEmbedder is created for a window once it has
-// a bounds, a valid FrameSinkId and is visible.
-TEST_F(WindowTreeClientWmTest, ClientSurfaceEmbedderOnValidEmbedding) {
+// a bounds, and a valid FrameSinkId.
+TEST_F(WindowTreeClientWmTestSurfaceSync,
+       ClientSurfaceEmbedderOnValidEmbedding) {
   Window window(nullptr);
   // 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));
   ASSERT_NE(new_bounds, window.bounds());
   window.SetBounds(new_bounds);
   EXPECT_EQ(new_bounds, window.bounds());
-  WindowMus* window_mus = WindowMus::Get(&window);
-  ASSERT_NE(nullptr, window_mus);
   EXPECT_TRUE(window_mus->GetLocalSurfaceId().is_valid());
 
-  // An ClientSurfaceEmbedder isn't created UNTIL the window is visible and has
+  // 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());
 
-  // The window is now visible, but doesn't yet have a FrameSinkId.
-  window.Show();
-  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));
-  EXPECT_NE(nullptr, window_port_mus->client_surface_embedder());
+  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());
+
+  // 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());
 }
 
 // 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 1956 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