Create a LayerDelegate for recreated layers to draw when their content is invalidated.

ash/wm/drag_window_resizer_unittest.cc

 // Copyright (c) 2012 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/wm/drag_window_resizer.h"
 
 #include "ash/display/display_manager.h"
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/cursor_manager_test_api.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/wm/aura/wm_window_aura.h"
 #include "ash/wm/common/window_positioning_utils.h"
 #include "ash/wm/drag_window_controller.h"
 #include "ash/wm/window_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
+#include "ui/compositor/layer_delegate.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/display/manager/display_layout.h"
 #include "ui/display/manager/display_layout_builder.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 namespace {
 
 const int kRootHeight = 600;
 
+// Used to test if the OnPaintLayer is called by DragWindowLayerDelegate.
+class TestLayerDelegate : public ui::LayerDelegate {
+ public:
+  TestLayerDelegate() = default;
+  ~TestLayerDelegate() override = default;
+
+  int paint_count() const { return paint_count_; }
+
+ private:
+  // Paint content for the layer to the specified context.
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    paint_count_++;
+  }
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  base::Closure PrepareForLayerBoundsChange() override {
+    return base::Closure();
+  }
+
+  int paint_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestLayerDelegate);
+};
+
 }  // namespace
 
 class DragWindowResizerTest : public test::AshTestBase {
  public:
   DragWindowResizerTest() : transient_child_(nullptr) {}
   ~DragWindowResizerTest() override {}
 
   void SetUp() override {
     AshTestBase::SetUp();
     UpdateDisplay(base::StringPrintf("800x%d", kRootHeight));
@@ skipping 289 matching lines @@
 
 // Verifies the drag window is shown correctly.
 TEST_F(DragWindowResizerTest, DragWindowController) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   ASSERT_EQ(2U, root_windows.size());
 
+  TestLayerDelegate delegate;
+  window_->layer()->set_delegate(&delegate);
   window_->SetBoundsInScreen(gfx::Rect(0, 0, 50, 60),
                              display::Screen::GetScreen()->GetPrimaryDisplay());
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
   EXPECT_FLOAT_EQ(1.0f, window_->layer()->opacity());
   {
     // Hold the center of the window so that the window doesn't stick to the
     // edge when dragging around the edge of the display.
     std::unique_ptr<WindowResizer> resizer(
         CreateDragWindowResizer(window_.get(), gfx::Point(25, 30), HTCAPTION));
     ASSERT_TRUE(resizer.get());
@@ skipping 14 matching lines @@
     const aura::Window* drag_window = controller->GetDragWindowForTest(0);
     ASSERT_TRUE(drag_window);
 
     const ui::Layer* drag_layer = drag_window->layer();
     ASSERT_TRUE(drag_layer);
     // Check if |resizer->layer_| is properly set to the drag widget.
     const std::vector<ui::Layer*>& layers = drag_layer->children();
     EXPECT_FALSE(layers.empty());
     EXPECT_EQ(controller->GetDragLayerOwnerForTest(0)->root(), layers.back());
 
+    // The paint request on a drag window should reach the original delegate.
+    controller->RequestLayerPaintForTest();
+    EXPECT_EQ(1, delegate.paint_count());
+
+    // Invalidating the delegate on the original layer should prevent
+    // calling the OnPaintLayer on the original delegate from new delegate.
+    window_->layer()->set_delegate(nullptr);
+    controller->RequestLayerPaintForTest();
+    EXPECT_EQ(1, delegate.paint_count());
+
     // |window_| should be opaque since the pointer is still on the primary
     // root window. The drag window should be semi-transparent.
     EXPECT_FLOAT_EQ(1.0f, window_->layer()->opacity());
     EXPECT_GT(1.0f, drag_layer->opacity());
 
     // Enter the pointer to the secondary display.
     resizer->Drag(CalculateDragPoint(*resizer, 775, 10), 0);
     EXPECT_EQ(1, controller->GetDragWindowsCountForTest());
     // |window_| should be transparent, and the drag window should be opaque.
     EXPECT_GT(1.0f, window_->layer()->opacity());
@@ skipping 340 matching lines @@
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 399, 200), 0);
     EXPECT_TRUE(TestIfMouseWarpsAt(gfx::Point(399, 200)));
     EXPECT_EQ("401,200",
               aura::Env::GetInstance()->last_mouse_location().ToString());
     resizer->CompleteDrag();
   }
 }
 
 }  // namespace ash