Use ShadowController instead of creating its own.

athena/wm/window_overview_mode.cc

 // Copyright 2014 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 "athena/wm/window_overview_mode.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "athena/common/closure_animation_observer.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/gestures/fling_curve.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/transform.h"
-#include "ui/wm/core/shadow.h"
+#include "ui/wm/core/shadow_types.h"
 
 namespace {
 
 struct WindowOverviewState {
   // The transform for when the window is at the topmost position.
   gfx::Transform top;
 
   // The transform for when the window is at the bottom-most position.
   gfx::Transform bottom;
 
   // The current overview state of the window. 0.f means the window is at the
   // topmost position. 1.f means the window is at the bottom-most position.
   float progress;
-
-  scoped_ptr<wm::Shadow> shadow;
 };
 
 }  // namespace
 
 DECLARE_WINDOW_PROPERTY_TYPE(WindowOverviewState*)
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(WindowOverviewState,
                                  kWindowOverviewState,
                                  NULL)
 namespace athena {
 
@@ skipping 15 matching lines @@
 
 // Resets the overview-related state for |window|.
 void RestoreWindowState(aura::Window* window) {
   window->ClearProperty(kWindowOverviewState);
 
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
   window->SetTransform(gfx::Transform());
+  wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
 }
 
 // Always returns the same target.
 class StaticWindowTargeter : public aura::WindowTargeter {
  public:
   explicit StaticWindowTargeter(aura::Window* target) : target_(target) {}
   virtual ~StaticWindowTargeter() {}
 
  private:
   // aura::WindowTargeter:
@@ skipping 71 matching lines @@
       gfx::Transform bottom_transform;
       int bottom = GetScrollableHeight() - (index * kGapBetweenWindowsBottom);
       x_translate = container_size.width() * (1 - kMaxScale) / 2.;
       bottom_transform.Translate(x_translate, bottom - window->bounds().y());
       bottom_transform.Scale(kMaxScale, kMaxScale);
 
       WindowOverviewState* state = new WindowOverviewState;
       state->top = top_transform;
       state->bottom = bottom_transform;
       state->progress = 0.f;
-      state->shadow = CreateShadowForWindow(window);
       window->SetProperty(kWindowOverviewState, state);
+      wm::SetShadowType(window, wm::SHADOW_TYPE_RECTANGULAR_ALWAYS_ACTIVE);
     }
   }
 
   // Sets the initial position for the windows for the overview mode.
   void SetInitialWindowStates() {
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
     size_t window_count = windows.size();
     // The initial overview state of the topmost three windows.
     const float kInitialProgress[] = { 0.5f, 0.05f, 0.01f };
     for (size_t i = 0; i < window_count; ++i) {
@@ skipping 17 matching lines @@
       {
         ui::ScopedLayerAnimationSettings settings(animator);
         settings.SetPreemptionStrategy(
             ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
         settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
         SetWindowProgress(window, progress);
       }
     }
   }
 
-  scoped_ptr<wm::Shadow> CreateShadowForWindow(aura::Window* window) {
-    scoped_ptr<wm::Shadow> shadow(new wm::Shadow());
-    shadow->Init(wm::Shadow::STYLE_ACTIVE);
-    shadow->SetContentBounds(gfx::Rect(container_->bounds().size()));
-    shadow->layer()->SetVisible(true);
-    window->layer()->Add(shadow->layer());
-    return shadow.Pass();
-  }
-
   aura::Window* SelectWindowAt(ui::LocatedEvent* event) {
     CHECK_EQ(container_, event->target());
     // Find the old targeter to find the target of the event.
     ui::EventTarget* window = container_;
     ui::EventTargeter* targeter = scoped_targeter_->old_targeter();
     while (!targeter && window->GetParentTarget()) {
       window = window->GetParentTarget();
       targeter = window->GetEventTargeter();
     }
     if (!targeter)
@@ skipping 268 matching lines @@
 // static
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* container,
     const WindowListProvider* window_list_provider,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, window_list_provider, delegate));
 }
 
 }  // namespace athena