[CrOS] Initial rough cut of alt-tab window cycling UI.

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/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/wm/forwarding_layer_delegate.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.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.
+// This keeps track of the drag window's state. It creates/destroys/updates
+// bounds and opacity based on the current bounds.
 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())) {}
 
@@ skipping 83 matching lines @@
     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);
+    wm::ForwardingLayerDelegate* new_delegate = new wm::ForwardingLayerDelegate(
+        WmWindowAura::Get(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 {
@@ skipping 19 matching lines @@
     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_;
+  std::vector<std::unique_ptr<wm::ForwardingLayerDelegate>> 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,
@@ skipping 70 matching lines @@
       layers.pop_back();
       if (layer->delegate())
         layer->delegate()->OnPaintLayer(context);
       for (auto* child : layer->children())
         layers.push_back(child);
     }
   }
 }
 
 }  // namespace ash