exo: Fix dragging edge cases

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/aura/wm_window_aura.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm_shell.h"
@@ skipping 32 matching lines @@
                              bool resizing,
                              bool activated) {
   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)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   surface->Attach(buffer.get());
   surface->Commit();
 
   gfx::Point origin(100, 100);
   shell_surface->GetWidget()->SetBounds(gfx::Rect(origin, buffer_size));
   EXPECT_EQ(origin.ToString(),
             surface->window()->GetBoundsInRootWindow().origin().ToString());
 
   const uint32_t kSerial = 1;
@@ skipping 13 matching lines @@
   surface->Commit();
 
   EXPECT_EQ(gfx::Point().ToString(),
             surface->window()->GetBoundsInRootWindow().origin().ToString());
 }
 
 TEST_F(ShellSurfaceTest, SetParent) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> parent_buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> parent_surface(new Surface);
   std::unique_ptr<ShellSurface> parent_shell_surface(
-      new ShellSurface(parent_surface.get()));
+      new ShellSurface(display, parent_surface.get()));
 
   parent_surface->Attach(parent_buffer.get());
   parent_surface->Commit();
 
   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()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
   shell_surface->SetParent(parent_shell_surface.get());
 
   surface->Attach(buffer.get());
   surface->Commit();
   EXPECT_EQ(
       parent_shell_surface->GetWidget()->GetNativeWindow(),
       wm::GetTransientParent(shell_surface->GetWidget()->GetNativeWindow()));
 }
 
 TEST_F(ShellSurfaceTest, Maximize) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   surface->Attach(buffer.get());
   shell_surface->Maximize();
   surface->Commit();
   EXPECT_EQ(CurrentContext()->bounds().width(),
             shell_surface->GetWidget()->GetWindowBoundsInScreen().width());
 }
 
 TEST_F(ShellSurfaceTest, Minimize) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   surface->Attach(buffer.get());
   surface->Commit();
   shell_surface->Minimize();
   EXPECT_TRUE(shell_surface->GetWidget()->IsMinimized());
 }
 
 TEST_F(ShellSurfaceTest, Restore) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   surface->Attach(buffer.get());
   surface->Commit();
   // Note: Remove contents to avoid issues with maximize animations in tests.
   shell_surface->Maximize();
   shell_surface->Restore();
   EXPECT_EQ(
       buffer_size.ToString(),
       shell_surface->GetWidget()->GetWindowBoundsInScreen().size().ToString());
 }
 
 TEST_F(ShellSurfaceTest, SetFullscreen) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   shell_surface->SetFullscreen(true);
   surface->Attach(buffer.get());
   surface->Commit();
   EXPECT_EQ(CurrentContext()->bounds().ToString(),
             shell_surface->GetWidget()->GetWindowBoundsInScreen().ToString());
 }
 
 TEST_F(ShellSurfaceTest, SetPinned) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   shell_surface->SetPinned(true, /* trusted */ true);
   EXPECT_TRUE(
       ash::wm::GetWindowState(shell_surface->GetWidget()->GetNativeWindow())
           ->IsPinned());
 
   shell_surface->SetPinned(false, /* trusted */ true);
   EXPECT_FALSE(
       ash::wm::GetWindowState(shell_surface->GetWidget()->GetNativeWindow())
           ->IsPinned());
 
   shell_surface->SetPinned(true, /* trusted */ false);
   EXPECT_TRUE(
       ash::wm::GetWindowState(shell_surface->GetWidget()->GetNativeWindow())
           ->IsPinned());
 
   shell_surface->SetPinned(false, /* trusted */ false);
   EXPECT_FALSE(
       ash::wm::GetWindowState(shell_surface->GetWidget()->GetNativeWindow())
           ->IsPinned());
 }
 
 TEST_F(ShellSurfaceTest, SetTitle) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   shell_surface->SetTitle(base::string16(base::ASCIIToUTF16("test")));
   surface->Commit();
 }
 
 TEST_F(ShellSurfaceTest, SetApplicationId) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   surface->Commit();
   EXPECT_EQ("", ShellSurface::GetApplicationId(
                     shell_surface->GetWidget()->GetNativeWindow()));
   shell_surface->SetApplicationId("test");
   EXPECT_EQ("test", ShellSurface::GetApplicationId(
                         shell_surface->GetWidget()->GetNativeWindow()));
 }
 
 TEST_F(ShellSurfaceTest, Move) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   // Map shell surface.
   surface->Commit();
 
   // The interactive move should end when surface is destroyed.
   shell_surface->Move();
 
   // Test that destroying the shell surface before move ends is OK.
   shell_surface.reset();
 }
 
 TEST_F(ShellSurfaceTest, Resize) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   // Map shell surface.
   surface->Commit();
 
   // The interactive resize should end when surface is destroyed.
   shell_surface->Resize(HTBOTTOMRIGHT);
 
   // Test that destroying the surface before resize ends is OK.
   surface.reset();
 }
 
 TEST_F(ShellSurfaceTest, SetGeometry) {
   gfx::Size buffer_size(64, 64);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   gfx::Rect geometry(16, 16, 32, 32);
   shell_surface->SetGeometry(geometry);
   surface->Attach(buffer.get());
   surface->Commit();
   EXPECT_EQ(
       geometry.size().ToString(),
       shell_surface->GetWidget()->GetWindowBoundsInScreen().size().ToString());
   EXPECT_EQ(gfx::Rect(gfx::Point() - geometry.OffsetFromOrigin(), buffer_size)
                 .ToString(),
             surface->window()->bounds().ToString());
 }
 
 TEST_F(ShellSurfaceTest, SetScale) {
   gfx::Size buffer_size(64, 64);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   double scale = 1.5;
   shell_surface->SetScale(scale);
   surface->Attach(buffer.get());
   surface->Commit();
 
   gfx::Transform transform;
   transform.Scale(1.0 / scale, 1.0 / scale);
   EXPECT_EQ(transform.ToString(),
             surface->window()->layer()->GetTargetTransform().ToString());
 }
 
 TEST_F(ShellSurfaceTest, SetTopInset) {
   gfx::Size buffer_size(64, 64);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   surface->Attach(buffer.get());
   surface->Commit();
 
   aura::Window* window = shell_surface->GetWidget()->GetNativeWindow();
   ASSERT_TRUE(window);
   EXPECT_EQ(0, window->GetProperty(aura::client::kTopViewInset));
   int top_inset_height = 20;
   shell_surface->SetTopInset(top_inset_height);
   surface->Commit();
   EXPECT_EQ(top_inset_height, window->GetProperty(aura::client::kTopViewInset));
 }
 
 void Close(int* close_call_count) {
   (*close_call_count)++;
 }
 
 TEST_F(ShellSurfaceTest, CloseCallback) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   int close_call_count = 0;
   shell_surface->set_close_callback(
       base::Bind(&Close, base::Unretained(&close_call_count)));
 
   surface->Commit();
 
   EXPECT_EQ(0, close_call_count);
   shell_surface->GetWidget()->Close();
   EXPECT_EQ(1, close_call_count);
 
   ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   shell_surface->GetWidget()->OnKeyEvent(&event);
   EXPECT_EQ(2, close_call_count);
 }
 
 void DestroyShellSurface(std::unique_ptr<ShellSurface>* shell_surface) {
   shell_surface->reset();
 }
 
 TEST_F(ShellSurfaceTest, SurfaceDestroyedCallback) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   shell_surface->set_surface_destroyed_callback(
       base::Bind(&DestroyShellSurface, base::Unretained(&shell_surface)));
 
   surface->Commit();
 
   EXPECT_TRUE(shell_surface.get());
   surface.reset();
   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) {
   *suggested_size = size;
   *has_state_type = state_type;
   *is_resizing = resizing;
   *is_active = activated;
   return 0;
 }
 
 TEST_F(ShellSurfaceTest, ConfigureCallback) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   gfx::Size suggested_size;
   ash::wm::WindowStateType has_state_type = ash::wm::WINDOW_STATE_TYPE_NORMAL;
   bool is_resizing = false;
   bool is_active = false;
   shell_surface->set_configure_callback(
       base::Bind(&Configure, base::Unretained(&suggested_size),
                  base::Unretained(&has_state_type),
                  base::Unretained(&is_resizing), base::Unretained(&is_active)));
   shell_surface->Maximize();
@@ skipping 23 matching lines @@
   shell_surface->AcknowledgeConfigure(0);
   EXPECT_FALSE(is_active);
 
   EXPECT_FALSE(is_resizing);
   shell_surface->Resize(HTBOTTOMRIGHT);
   shell_surface->AcknowledgeConfigure(0);
   EXPECT_TRUE(is_resizing);
 }
 
 TEST_F(ShellSurfaceTest, ModalWindow) {
+  Display display;
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(), true,
+      new ShellSurface(display, surface.get(), nullptr, gfx::Rect(), true,
                        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.
-  std::unique_ptr<Display> display(new Display);
-  std::unique_ptr<Surface> child = display->CreateSurface();
+  std::unique_ptr<Surface> child = display.CreateSurface();
   gfx::Size buffer_size(128, 128);
   std::unique_ptr<Buffer> child_buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   child->Attach(child_buffer.get());
   std::unique_ptr<SubSurface> sub_surface(
-      display->CreateSubSurface(child.get(), surface.get()));
+      display.CreateSubSurface(child.get(), surface.get()));
   surface->SetSubSurfacePosition(child.get(), gfx::Point(10, 10));
   child->Commit();
   surface->Commit();
   EXPECT_FALSE(ash::WmShell::Get()->IsSystemModalWindowOpen());
 
   // Making the surface opaque shouldn't make it modal either.
   child->SetBlendMode(SkXfermode::kSrc_Mode);
   child->Commit();
   surface->Commit();
   EXPECT_FALSE(ash::WmShell::Get()->IsSystemModalWindowOpen());
 
   // Setting input regions won't make it modal either.
   surface->SetInputRegion(
       SkRegion(gfx::RectToSkIRect(gfx::Rect(10, 10, 100, 100))));
   surface->Commit();
   EXPECT_FALSE(ash::WmShell::Get()->IsSystemModalWindowOpen());
 
   // Only SetSystemModal changes modality.
   shell_surface->SetSystemModal(true);
   EXPECT_TRUE(ash::WmShell::Get()->IsSystemModalWindowOpen());
 
   shell_surface->SetSystemModal(false);
   EXPECT_FALSE(ash::WmShell::Get()->IsSystemModalWindowOpen());
 }
 
 TEST_F(ShellSurfaceTest, Shadow) {
+  Display display;
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(), true,
+      new ShellSurface(display, surface.get(), nullptr, gfx::Rect(), true,
                        ash::kShellWindowId_DefaultContainer));
   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());
 
-  std::unique_ptr<Display> display(new Display);
-
   // 2) Just creating a sub surface won't create a shadow.
-  std::unique_ptr<Surface> child = display->CreateSurface();
+  std::unique_ptr<Surface> child = display.CreateSurface();
   gfx::Size buffer_size(128, 128);
   std::unique_ptr<Buffer> child_buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   child->Attach(child_buffer.get());
   std::unique_ptr<SubSurface> sub_surface(
-      display->CreateSubSurface(child.get(), surface.get()));
+      display.CreateSubSurface(child.get(), surface.get()));
   surface->Commit();
 
   EXPECT_FALSE(shadow->layer()->visible());
 
   // 3) Create a shadow.
   shell_surface->SetRectangularShadow(gfx::Rect(10, 10, 100, 100));
   surface->Commit();
   EXPECT_TRUE(shadow->layer()->visible());
 
   gfx::Rect before = shadow->layer()->bounds();
@@ skipping 21 matching lines @@
 
   // 6) Setting non empty content bounds should enable shadow.
   shell_surface->SetRectangularShadow(gfx::Rect(10, 10, 100, 100));
   surface->Commit();
 
   EXPECT_EQ(wm::SHADOW_TYPE_RECTANGULAR, wm::GetShadowType(window));
   EXPECT_TRUE(shadow->layer()->visible());
 }
 
 TEST_F(ShellSurfaceTest, ShadowWithStateChange) {
+  const Display display;
   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,
-                       ash::kShellWindowId_DefaultContainer));
+      new ShellSurface(display, surface.get(), nullptr, gfx::Rect(640, 480),
+                       true, 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->Commit();
 
   // Placing a shadow at screen origin will make the shadow's origin (-10, -10).
   const gfx::Rect shadow_bounds(content_size);
 
@@ skipping 33 matching lines @@
   const gfx::Rect shadow_in_maximized(expected_shadow_origin, work_area.size());
   EXPECT_EQ(shadow_in_maximized, shadow->layer()->parent()->bounds());
 
   // The bounds is updated.
   shell_surface->SetRectangularShadow(shadow_bounds);
   surface->Commit();
   EXPECT_EQ(expected_shadow_bounds, shadow->layer()->parent()->bounds());
 }
 
 TEST_F(ShellSurfaceTest, ShadowWithTransform) {
+  const Display display;
   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,
-                       ash::kShellWindowId_DefaultContainer));
+      new ShellSurface(display, surface.get(), nullptr, gfx::Rect(640, 400),
+                       true, 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->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(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) {
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(640, 480), true,
-                       ash::kShellWindowId_DefaultContainer));
+      new ShellSurface(display, surface.get(), nullptr, gfx::Rect(640, 480),
+                       true, 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(gfx::Rect(10, 10, 100, 100));
   surface->Commit();
 
   EXPECT_FALSE(wm::ShadowController::GetShadowForWindow(window));
   // Underlay should be created even without shadow.
   ASSERT_TRUE(shell_surface->shadow_underlay());
   EXPECT_TRUE(shell_surface->shadow_underlay()->IsVisible());
 
   // Restore the window and make sure the shadow is created, visible and
   // has the latest bounds.
   widget->Restore();
   wm::Shadow* shadow = wm::ShadowController::GetShadowForWindow(window);
   ASSERT_TRUE(shadow);
   EXPECT_TRUE(shadow->layer()->visible());
   EXPECT_EQ(gfx::Rect(10, 10, 100, 100), shadow->layer()->parent()->bounds());
 }
 
 TEST_F(ShellSurfaceTest, ToggleFullscreen) {
   gfx::Size buffer_size(256, 256);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
-  std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
+  std::unique_ptr<ShellSurface> shell_surface(
+      new ShellSurface(display, surface.get()));
 
   surface->Attach(buffer.get());
   surface->Commit();
   EXPECT_EQ(
       buffer_size.ToString(),
       shell_surface->GetWidget()->GetWindowBoundsInScreen().size().ToString());
 
   shell_surface->Maximize();
   EXPECT_EQ(CurrentContext()->bounds().width(),
             shell_surface->GetWidget()->GetWindowBoundsInScreen().width());
@@ skipping 13 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)));
+  const Display display;
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(
-      new ShellSurface(surface.get(), nullptr, gfx::Rect(640, 480), true,
-                       ash::kShellWindowId_DefaultContainer));
+      new ShellSurface(display, surface.get(), nullptr, gfx::Rect(640, 480),
+                       true, ash::kShellWindowId_DefaultContainer));
 
   surface->Attach(buffer.get());
 
   gfx::Rect shadow_bounds(10, 10, 100, 100);
   shell_surface->SetRectangularShadow(shadow_bounds);
   surface->Commit();
   ASSERT_EQ(shadow_bounds, shell_surface->shadow_underlay()->bounds());
 
   ash::wm::WMEvent event(ash::wm::WM_EVENT_TOGGLE_FULLSCREEN);
   ash::WmWindow* window =
@@ skipping 11 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));
+  const Display display;
   Surface surface;
-  ShellSurface shell_surface(&surface, nullptr, gfx::Rect(640, 480), true,
-                             ash::kShellWindowId_DefaultContainer);
+  ShellSurface shell_surface(display, &surface, nullptr, gfx::Rect(640, 480),
+                             true, ash::kShellWindowId_DefaultContainer);
 
   surface.Attach(&buffer);
 
   gfx::Rect shadow_bounds(10, 10, 100, 100);
   shell_surface.SetRectangularShadow(shadow_bounds);
   surface.Commit();
   ASSERT_EQ(shadow_bounds, shell_surface.shadow_underlay()->bounds());
 
   aura::Window* shell_window = shell_surface.GetWidget()->GetNativeWindow();
   aura::WindowTargeter* targeter = static_cast<aura::WindowTargeter*>(
@@ skipping 24 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,
-                              ash::kShellWindowId_DefaultContainer);
+  ShellSurface shell_surface2(display, &surface2, nullptr, gfx::Rect(640, 480),
+                              true, ash::kShellWindowId_DefaultContainer);
   surface2.Attach(&buffer2);
   shell_surface2.SetRectangularShadow(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(ash::A11Y_NOTIFICATION_NONE);
   shell_surface2.OnAccessibilityModeChanged(ash::A11Y_NOTIFICATION_NONE);
 
   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