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

ash/wm/drag_window_controller.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_controller.h"
 
 #include <algorithm>
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_tree_owner.h"
+#include "ui/compositor/paint_context.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
+namespace {
+
+// A layer delegate to paint the content of the recreaetd layers
+// by delegating the paint request to the original delegate.
+// It checks if the orignal delegate is still valid by traversing
+// the original layers.
+class DragWindowLayerDelegate : public ui::LayerDelegate {
+ public:
+  DragWindowLayerDelegate(aura::Window* original_window,
+                          ui::LayerDelegate* delegate)
+      : original_window_(original_window), original_delegate_(delegate) {}
+  ~DragWindowLayerDelegate() override {}
+
+ private:
+  // ui:LayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    if (!original_delegate_)
+      return;
+    // |original_delegate_| may have already been deleted or
+    // disconnected by this time. Check if |original_delegate_| is still
+    // used by the original_window tree, or skip otherwise.
+    if (IsDelegateValid(original_window_->layer()))
+      original_delegate_->OnPaintLayer(context);
+    else
+      original_delegate_ = nullptr;
+  }
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {
+    // Don't tell the original delegate about device scale factor change
+    // on cloned layer because the original layer is still on the same display.
+  }
+  base::Closure PrepareForLayerBoundsChange() override {
+    return base::Closure();
+  }
+
+  bool IsDelegateValid(ui::Layer* layer) {
+    if (layer->delegate() == original_delegate_)
+      return true;
+    for (auto* child : layer->children()) {
+      if (IsDelegateValid(child))
+        return true;
+    }
+    return false;
+  }
+
+  aura::Window* original_window_;
+  ui::LayerDelegate* original_delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(DragWindowLayerDelegate);
+};
+
+}  // namespace
 
 // This keeps tack of the drag window's state. It creates/destory/updates bounds
 // and opacity based on the current bounds.
-class DragWindowController::DragWindowDetails : public aura::WindowDelegate {
+class DragWindowController::DragWindowDetails
+    : public aura::WindowDelegate,
+      public ::wm::LayerDelegateFactory {
  public:
   DragWindowDetails(const display::Display& display,
                     aura::Window* original_window)
       : root_window_(Shell::GetInstance()
                          ->window_tree_host_manager()
                          ->GetRootWindowForDisplayId(display.id())) {}
 
   ~DragWindowDetails() override {
     delete drag_window_;
     DCHECK(!drag_window_);
@@ skipping 27 matching lines @@
                  GetDragWindowOpacity(bounds_in_screen, visible_bounds));
     }
   }
 
  private:
   friend class DragWindowController;
 
   void CreateDragWindow(aura::Window* original_window,
                         const gfx::Rect& bounds_in_screen) {
     DCHECK(!drag_window_);
+    original_window_ = original_window;
     drag_window_ = new aura::Window(this);
     int parent_id = original_window->parent()->id();
     aura::Window* container = root_window_->GetChildById(parent_id);
 
     drag_window_->SetType(ui::wm::WINDOW_TYPE_POPUP);
     drag_window_->SetTransparent(true);
     drag_window_->Init(ui::LAYER_TEXTURED);
     drag_window_->SetName("DragWindow");
     drag_window_->set_id(kShellWindowId_PhantomWindow);
     drag_window_->SetProperty(aura::client::kAnimationsDisabledKey, true);
@@ skipping 11 matching lines @@
 
     // Fade the window in.
     ui::Layer* drag_layer = drag_window_->layer();
     drag_layer->SetOpacity(0);
     ui::ScopedLayerAnimationSettings scoped_setter(drag_layer->GetAnimator());
     drag_layer->SetOpacity(1);
   }
 
   void RecreateWindowLayers(aura::Window* original_window) {
     DCHECK(!layer_owner_.get());
-    layer_owner_ = ::wm::RecreateLayers(original_window);
-    // TODO(oshima): Recreated child layers may not have been painted
-    // yet, and may not be able to paint to because it does not have
-    // its original delegate.
-    layer_owner_->root()->set_delegate(original_window->layer()->delegate());
+    layer_owner_ = ::wm::RecreateLayers(original_window, this);
     // Place the layer at (0, 0) of the DragWindowController's window.
     gfx::Rect layer_bounds = layer_owner_->root()->bounds();
     layer_bounds.set_origin(gfx::Point(0, 0));
     layer_owner_->root()->SetBounds(layer_bounds);
     layer_owner_->root()->SetVisible(false);
     // Detach it from the current container.
     layer_owner_->root()->parent()->Remove(layer_owner_->root());
   }
 
   void SetOpacity(const aura::Window* original_window, float opacity) {
     ui::Layer* layer = drag_window_->layer();
     ui::ScopedLayerAnimationSettings scoped_setter(layer->GetAnimator());
     layer->SetOpacity(opacity);
     layer_owner_->root()->SetOpacity(1.0f);
   }
 
   // aura::WindowDelegate:
+  ui::LayerDelegate* CreateDelegate(ui::LayerDelegate* delegate) override {
+    if (!delegate)
+      return nullptr;
+    DragWindowLayerDelegate* new_delegate =
+        new DragWindowLayerDelegate(original_window_, delegate);
+    delegates_.push_back(base::WrapUnique(new_delegate));
+    return new_delegate;
+  }
+
+  // aura::WindowDelegate:
   gfx::Size GetMinimumSize() const override { return gfx::Size(); }
   gfx::Size GetMaximumSize() const override { return gfx::Size(); }
   void OnBoundsChanged(const gfx::Rect& old_bounds,
                        const gfx::Rect& new_bounds) override {}
   gfx::NativeCursor GetCursor(const gfx::Point& point) override {
     return gfx::kNullCursor;
   }
   int GetNonClientComponent(const gfx::Point& point) const override {
     return HTNOWHERE;
   }
@@ skipping 12 matching lines @@
   void GetHitTestMask(gfx::Path* mask) const override {}
   void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(drag_window_, window);
     drag_window_ = nullptr;
   }
 
   aura::Window* root_window_;
 
   aura::Window* drag_window_ = nullptr;  // Owned by the container.
 
+  aura::Window* original_window_ = nullptr;
+
+  std::vector<std::unique_ptr<DragWindowLayerDelegate>> delegates_;
+
   // The copy of window_->layer() and its descendants.
   std::unique_ptr<ui::LayerTreeOwner> layer_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(DragWindowDetails);
 };
 
 // static
 float DragWindowController::GetDragWindowOpacity(
     const gfx::Rect& window_bounds,
     const gfx::Rect& visible_bounds) {
@@ skipping 52 matching lines @@
   for (const std::unique_ptr<DragWindowDetails>& details : drag_windows_) {
     if (details->layer_owner_) {
       if (index == 0)
         return details->layer_owner_.get();
       index--;
     }
   }
   return nullptr;
 }
 
+void DragWindowController::RequestLayerPaintForTest() {
+  ui::PaintContext context(nullptr, 1.0f, gfx::Rect());
+  for (auto& details : drag_windows_) {
+    std::vector<ui::Layer*> layers;
+    layers.push_back(details->drag_window_->layer());
+    while (layers.size()) {
+      ui::Layer* layer = layers.back();
+      layers.pop_back();
+      if (layer->delegate())
+        layer->delegate()->OnPaintLayer(context);
+      for (auto* child : layer->children())
+        layers.push_back(child);
+    }
+  }
+}
+
 }  // namespace ash