exo: Initial support for multiple displays in ARC

components/exo/shell_surface_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 "ash/common/accessibility_delegate.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
@@ skipping 23 matching lines @@
 
 namespace exo {
 namespace {
 
 using ShellSurfaceTest = test::ExoTestBase;
 
 uint32_t ConfigureFullscreen(uint32_t serial,
                              const gfx::Size& size,
                              ash::wm::WindowStateType state_type,
                              bool resizing,
-                             bool activated) {
+                             bool activated,
+                             const gfx::Point& origin) {
   EXPECT_EQ(ash::wm::WINDOW_STATE_TYPE_FULLSCREEN, state_type);
   return serial;
 }
 
 TEST_F(ShellSurfaceTest, AcknowledgeConfigure) {
   gfx::Size buffer_size(32, 32);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
@@ skipping 301 matching lines @@
   EXPECT_FALSE(shell_surface.get());
 }
 
 uint32_t Configure(gfx::Size* suggested_size,
                    ash::wm::WindowStateType* has_state_type,
                    bool* is_resizing,
                    bool* is_active,
                    const gfx::Size& size,
                    ash::wm::WindowStateType state_type,
                    bool resizing,
-                   bool activated) {
+                   bool activated,
+                   const gfx::Point& origin) {
   *suggested_size = size;
   *has_state_type = state_type;
   *is_resizing = resizing;
   *is_active = activated;
   return 0;
 }
 
 TEST_F(ShellSurfaceTest, ConfigureCallback) {
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
@@ skipping 34 matching lines @@
   EXPECT_FALSE(is_active);
 
   EXPECT_FALSE(is_resizing);
   shell_surface->Resize(HTBOTTOMRIGHT);
   shell_surface->AcknowledgeConfigure(0);
   EXPECT_TRUE(is_resizing);
 }
 
 TEST_F(ShellSurfaceTest, ModalWindow) {
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(), true, false,
-                       ash::kShellWindowId_SystemModalContainer));
+  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(
+      surface.get(), nullptr, ShellSurface::BoundsMode::SHELL, gfx::Point(),
+      true, false, ash::kShellWindowId_SystemModalContainer));
   gfx::Size desktop_size(640, 480);
   std::unique_ptr<Buffer> desktop_buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(desktop_size)));
   surface->Attach(desktop_buffer.get());
   surface->SetInputRegion(SkRegion());
   surface->Commit();
 
   EXPECT_FALSE(ash::WmShell::Get()->IsSystemModalWindowOpen());
 
   // Creating a surface without input region should not make it modal.
@@ skipping 68 matching lines @@
                       geometry.OffsetFromOrigin(),
                       geometry.size()),
             popup->GetWidget()->GetWindowBoundsInScreen());
 }
 
 TEST_F(ShellSurfaceTest, Shadow) {
   gfx::Size buffer_size(128, 128);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(), true, false,
-                       ash::kShellWindowId_DefaultContainer));
+  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(
+      surface.get(), nullptr, ShellSurface::BoundsMode::SHELL, gfx::Point(),
+      true, false, ash::kShellWindowId_DefaultContainer));
   surface->Attach(buffer.get());
   surface->Commit();
 
   aura::Window* window = shell_surface->GetWidget()->GetNativeWindow();
 
   // 1) Initial state, no shadow.
   wm::Shadow* shadow = wm::ShadowController::GetShadowForWindow(window);
   ASSERT_TRUE(shadow);
   EXPECT_FALSE(shadow->layer()->visible());
 
@@ skipping 53 matching lines @@
   ASSERT_NE(underlay_it, window->children().end());
   ASSERT_NE(std::next(underlay_it), window->children().end());
   EXPECT_EQ(*std::next(underlay_it), shell_surface->shadow_overlay());
 }
 
 TEST_F(ShellSurfaceTest, ShadowWithStateChange) {
   gfx::Size buffer_size(64, 64);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   std::unique_ptr<Surface> surface(new Surface);
-  // Set the bounds to disable auto managed mode.
-  std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(640, 480), true, false,
-                       ash::kShellWindowId_DefaultContainer));
+  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(
+      surface.get(), nullptr, ShellSurface::BoundsMode::CLIENT, gfx::Point(),
+      true, false, ash::kShellWindowId_DefaultContainer));
 
   // Postion the widget at 10,10 so that we get non zero offset.
   const gfx::Size content_size(100, 100);
   const gfx::Rect original_bounds(gfx::Point(10, 10), content_size);
   shell_surface->SetGeometry(original_bounds);
   surface->Attach(buffer.get());
   surface->Commit();
 
   // Placing a shadow at screen origin will make the shadow's origin (-10, -10).
   const gfx::Rect shadow_bounds(content_size);
@@ skipping 39 matching lines @@
   shell_surface->SetRectangularShadowContentBounds(shadow_bounds);
   surface->Commit();
   EXPECT_EQ(expected_shadow_bounds, shadow->layer()->parent()->bounds());
 }
 
 TEST_F(ShellSurfaceTest, ShadowWithTransform) {
   gfx::Size buffer_size(64, 64);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   std::unique_ptr<Surface> surface(new Surface);
-  // Set the bounds to disable auto managed mode.
-  std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(640, 400), true, false,
-                       ash::kShellWindowId_DefaultContainer));
+  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(
+      surface.get(), nullptr, ShellSurface::BoundsMode::CLIENT, gfx::Point(),
+      true, false, ash::kShellWindowId_DefaultContainer));
 
   // Postion the widget at 10,10 so that we get non zero offset.
   const gfx::Size content_size(100, 100);
   const gfx::Rect original_bounds(gfx::Point(10, 10), content_size);
   shell_surface->SetGeometry(original_bounds);
   surface->Attach(buffer.get());
   surface->Commit();
 
   aura::Window* window = shell_surface->GetWidget()->GetNativeWindow();
   wm::Shadow* shadow = wm::ShadowController::GetShadowForWindow(window);
 
   // Placing a shadow at screen origin will make the shadow's origin (-10, -10).
   const gfx::Rect shadow_bounds(content_size);
 
   // Shadow bounds relative to its parent should not be affected by a transform.
   gfx::Transform transform;
   transform.Translate(50, 50);
   window->SetTransform(transform);
   shell_surface->SetRectangularShadow(true);
   shell_surface->SetRectangularShadowContentBounds(shadow_bounds);
   surface->Commit();
   EXPECT_TRUE(shadow->layer()->visible());
   EXPECT_EQ(gfx::Rect(-10, -10, 100, 100), shadow->layer()->parent()->bounds());
 }
 
 TEST_F(ShellSurfaceTest, ShadowStartMaximized) {
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(640, 480), true, false,
-                       ash::kShellWindowId_DefaultContainer));
+  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(
+      surface.get(), nullptr, ShellSurface::BoundsMode::CLIENT, gfx::Point(),
+      true, false, ash::kShellWindowId_DefaultContainer));
   shell_surface->Maximize();
   views::Widget* widget = shell_surface->GetWidget();
   aura::Window* window = widget->GetNativeWindow();
 
   // There is no shadow when started in maximized state.
   EXPECT_FALSE(wm::ShadowController::GetShadowForWindow(window));
 
   // Sending a shadow bounds in maximized state won't create a shaodw.
   shell_surface->SetRectangularShadow(true);
   shell_surface->SetRectangularShadowContentBounds(gfx::Rect(10, 10, 100, 100));
@@ skipping 46 matching lines @@
   // Check that shell surface is maximized.
   EXPECT_EQ(CurrentContext()->bounds().width(),
             shell_surface->GetWidget()->GetWindowBoundsInScreen().width());
 }
 
 TEST_F(ShellSurfaceTest, ImmersiveFullscreenBackground) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(640, 480), true, false,
-                       ash::kShellWindowId_DefaultContainer));
+  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(
+      surface.get(), nullptr, ShellSurface::BoundsMode::CLIENT, gfx::Point(),
+      true, false, ash::kShellWindowId_DefaultContainer));
 
   surface->Attach(buffer.get());
 
   gfx::Rect shadow_bounds(10, 10, 100, 100);
   shell_surface->SetRectangularShadow(true);
   shell_surface->SetRectangularShadowContentBounds(shadow_bounds);
   surface->Commit();
   ASSERT_EQ(shadow_bounds, shell_surface->shadow_underlay()->bounds());
 
   ash::wm::WMEvent event(ash::wm::WM_EVENT_TOGGLE_FULLSCREEN);
@@ skipping 13 matching lines @@
   // Leave fullscreen mode. Shadow underlay is restored.
   window->GetWindowState()->OnWMEvent(&event);
   EXPECT_TRUE(shell_surface->shadow_underlay()->IsVisible());
   EXPECT_EQ(shadow_bounds, shell_surface->shadow_underlay()->bounds());
 }
 
 TEST_F(ShellSurfaceTest, SpokenFeedbackFullscreenBackground) {
   gfx::Size buffer_size(256, 256);
   Buffer buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size));
   Surface surface;
-  ShellSurface shell_surface(&surface, nullptr, gfx::Rect(640, 480), true,
-                             false, ash::kShellWindowId_DefaultContainer);
+  ShellSurface shell_surface(&surface, nullptr,
+                             ShellSurface::BoundsMode::CLIENT, gfx::Point(),
+                             true, false, ash::kShellWindowId_DefaultContainer);
 
   surface.Attach(&buffer);
 
   gfx::Rect shadow_bounds(10, 10, 100, 100);
   shell_surface.SetRectangularShadow(true);
   shell_surface.SetRectangularShadowContentBounds(shadow_bounds);
   surface.Commit();
   ASSERT_EQ(shadow_bounds, shell_surface.shadow_underlay()->bounds());
 
   aura::Window* shell_window = shell_surface.GetWidget()->GetNativeWindow();
@@ skipping 25 matching lines @@
   EXPECT_EQ(shell_surface.shadow_underlay(),
             static_cast<ui::EventTargeter*>(targeter)->FindTargetForEvent(
                 shell_window, &ev_out));
   EXPECT_NE(shell_surface.shadow_underlay(),
             static_cast<ui::EventTargeter*>(targeter)->FindTargetForEvent(
                 shell_window, &ev_in));
 
   // Create a new surface
   Buffer buffer2(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size));
   Surface surface2;
-  ShellSurface shell_surface2(&surface2, nullptr, gfx::Rect(640, 480), true,
-                              false, ash::kShellWindowId_DefaultContainer);
+  ShellSurface shell_surface2(
+      &surface2, nullptr, ShellSurface::BoundsMode::CLIENT, gfx::Point(), true,
+      false, ash::kShellWindowId_DefaultContainer);
   surface2.Attach(&buffer2);
   shell_surface2.SetRectangularShadow(true);
   shell_surface2.SetRectangularShadowContentBounds(shadow_bounds);
   surface2.Commit();
 
   // spoken-feedback was already on, so underlay should fill screen
   EXPECT_EQ(display::Screen::GetScreen()->GetPrimaryDisplay().bounds(),
             shell_surface2.shadow_underlay()->bounds());
 
   // De-activated shell-surface should NOT have fullscreen underlay
   EXPECT_EQ(shadow_bounds, shell_surface.shadow_underlay()->bounds());
 
   // Disable spoken feedback. Shadow underlay is restored.
   ash::WmShell::Get()->accessibility_delegate()->ToggleSpokenFeedback(
       ash::A11Y_NOTIFICATION_NONE);
   shell_surface.OnAccessibilityModeChanged();
   shell_surface2.OnAccessibilityModeChanged();
 
   EXPECT_TRUE(shell_surface.shadow_underlay()->IsVisible());
   EXPECT_EQ(shadow_bounds, shell_surface.shadow_underlay()->bounds());
   EXPECT_EQ(shadow_bounds, shell_surface2.shadow_underlay()->bounds());
 }
 
 }  // namespace
 }  // namespace exo