Converts ash to use aura-mus

ash/mus/shadow.cc

 // Copyright 2015 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/mus/shadow.h"
 
-#include "ash/mus/property_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_property.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/resources/grit/ui_resources.h"
 
+DECLARE_WINDOW_PROPERTY_TYPE(ash::mus::Shadow*);
+
 namespace ash {
 namespace mus {
+namespace {
 
-namespace {
+DEFINE_WINDOW_PROPERTY_KEY(Shadow*, kShadowProperty, nullptr);
 
 // The opacity used for active shadow when animating between
 // inactive/active shadow.
 const float kInactiveShadowAnimationOpacity = 0.2f;
 
 // Shadow aperture for different styles.
 // Note that this may be greater than interior inset to allow shadows with
 // curved corners that extend inwards beyond a window's borders.
 const int kActiveInteriorAperture = 134;
 const int kInactiveInteriorAperture = 134;
@@ skipping 22 matching lines @@
   }
   return 0;
 }
 
 }  // namespace
 
 Shadow::Shadow() : style_(STYLE_ACTIVE), interior_inset_(0), window_(nullptr) {}
 
 Shadow::~Shadow() {
   if (window_) {
-    SetShadow(window_, nullptr);
+    window_->ClearProperty(kShadowProperty);
     window_->RemoveObserver(this);
   }
 }
 
 void Shadow::Init(Style style) {
   style_ = style;
 
   layer_.reset(new ui::Layer(ui::LAYER_NOT_DRAWN));
   shadow_layer_.reset(new ui::Layer(ui::LAYER_NINE_PATCH));
   layer()->Add(shadow_layer_.get());
 
   UpdateImagesForStyle();
   shadow_layer_->set_name("Shadow");
   shadow_layer_->SetVisible(true);
   shadow_layer_->SetFillsBoundsOpaquely(false);
 }
 
 // static
+Shadow* Shadow::Get(aura::Window* window) {
+  return window->GetProperty(kShadowProperty);
+}
+
+// static
 int Shadow::GetInteriorInsetForStyle(Shadow::Style style) {
   switch (style) {
     case Shadow::STYLE_ACTIVE:
       return kActiveInteriorInset;
     case Shadow::STYLE_INACTIVE:
       return kInactiveInteriorInset;
     case Shadow::STYLE_SMALL:
       return kSmallInteriorInset;
   }
   return 0;
@@ skipping 48 matching lines @@
         // The opacity will be reset to 1.0f when animation is completed.
         shadow_layer_->SetOpacity(kInactiveShadowAnimationOpacity);
         break;
       default:
         NOTREACHED() << "Unhandled style " << style_;
         break;
     }
   }
 }
 
-void Shadow::Install(ui::Window* window) {
-  SetShadow(window, this);
+void Shadow::Install(aura::Window* window) {
+  window->SetProperty(kShadowProperty, this);
   window_ = window;
   window_->AddObserver(this);
 }
 
 void Shadow::OnImplicitAnimationsCompleted() {
   // If we just finished going inactive, switch images.  This doesn't cause
   // a visual pop because the inactive image opacity is so low.
   if (style_ == STYLE_INACTIVE) {
     UpdateImagesForStyle();
     // Opacity is baked into inactive image, so set fully opaque.
@@ skipping 50 matching lines @@
   // The content bounds in the shadow's layer space are offsetted by
   // |interior_inset_|. The occlusion area also has to be shrunk to allow
   // rounded corners overdrawing on top of the window's content.
   gfx::Rect content_bounds(interior_inset_ + kRoundedCornerRadius,
                            interior_inset_ + kRoundedCornerRadius,
                            content_bounds_.width() - 2 * kRoundedCornerRadius,
                            content_bounds_.height() - 2 * kRoundedCornerRadius);
   shadow_layer_->UpdateNinePatchOcclusion(content_bounds);
 }
 
-void Shadow::OnWindowDestroyed(ui::Window* window) {
+void Shadow::OnWindowDestroyed(aura::Window* window) {
   DCHECK_EQ(window_, window);
   window_ = nullptr;
 }
 
 }  // namespace mus
 }  // namespace ash