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/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 {
+
+class DragWindowLayerDelegate : public ui::LayerDelegate {

[sky, 2016/05/19 20:06:49]

Description

[oshima, 2016/05/19 23:32:21]

Done.

+ public:
+  DragWindowLayerDelegate(ui::LayerDelegate* delegate)

[sky, 2016/05/19 20:06:49]

How do you know the original delegate remains valid for the life of the drag?
Certainly the delegate for the window itself being dragged is valid, but for any
child layers the delegate may be destroyed at any time during the drag, right?

[sky, 2016/05/19 20:06:49]

explicit

[oshima, 2016/05/19 23:32:21]

You're right. The only way to check, without introducing another
delegate/observer, is to traverse the layer tree unfortunately. I feel
introducing such interface just for this use case is overkill, and this does not
happen very often, so I took that approach for now. I'm happy to add one if you
prefer that way so let me know.

+      : original_delegate_(delegate) {}
+  ~DragWindowLayerDelegate() override {}
+
+ private:
+  // ui:LLayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    original_delegate_->OnPaintLayer(context);
+  }
+  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();
+  }
+
+  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 58 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 {
+    DragWindowLayerDelegate* new_delegate =
+        new DragWindowLayerDelegate(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.
 
+  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 53 matching lines @@
     if (details->layer_owner_) {
       if (index == 0)
         return details->layer_owner_.get();
       index--;
     }
   }
   return nullptr;
 }
 
 }  // namespace ash