Moves mash/wm into ash/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 "mash/wm/shadow.h"
+#include "ash/mus/shadow.h"
 
-#include "mash/wm/property_util.h"
+#include "ash/mus/property_util.h"
 #include "third_party/skia/include/core/SkBitmap.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"
 
-namespace mash {
-namespace wm {
+namespace ash {
+namespace mus {
 
 namespace {
 
 // 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;
 const int kSmallInteriorAperture = 9;
 
 // Interior inset for different styles.
 const int kActiveInteriorInset = 64;
 const int kInactiveInteriorInset = 64;
 const int kSmallInteriorInset = 4;
 
 // Duration for opacity animation in milliseconds.
 const int kShadowAnimationDurationMs = 100;
 
-int GetShadowApertureForStyle(wm::Shadow::Style style) {
+int GetShadowApertureForStyle(Shadow::Style style) {
   switch (style) {
-    case wm::Shadow::STYLE_ACTIVE:
+    case Shadow::STYLE_ACTIVE:
       return kActiveInteriorAperture;
-    case wm::Shadow::STYLE_INACTIVE:
+    case Shadow::STYLE_INACTIVE:
       return kInactiveInteriorAperture;
-    case wm::Shadow::STYLE_SMALL:
+    case Shadow::STYLE_SMALL:
       return kSmallInteriorAperture;
   }
   return 0;
 }
 
 }  // namespace
 
-Shadow::Shadow() : style_(STYLE_ACTIVE), interior_inset_(0), window_(nullptr) {
-}
+Shadow::Shadow() : style_(STYLE_ACTIVE), interior_inset_(0), window_(nullptr) {}
 
 Shadow::~Shadow() {
   if (window_) {
     SetShadow(window_, nullptr);
     window_->RemoveObserver(this);
   }
 }
 
 void Shadow::Init(Style style) {
   style_ = style;
@@ skipping 70 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(mus::Window* window) {
+void Shadow::Install(::mus::Window* window) {
   SetShadow(window, 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();
@@ skipping 34 matching lines @@
   layer_bounds.Inset(-interior_inset_, -interior_inset_);
   layer()->SetBounds(layer_bounds);
   shadow_layer_->SetBounds(gfx::Rect(layer_bounds.size()));
 
   // Update the shadow aperture and border for style. Note that border is in
   // layer space and it cannot exceed the bounds of the layer.
   int aperture = GetShadowApertureForStyle(style_);
   int aperture_x = std::min(aperture, layer_bounds.width() / 2);
   int aperture_y = std::min(aperture, layer_bounds.height() / 2);
   shadow_layer_->UpdateNinePatchLayerAperture(
-      gfx::Rect(aperture_x, aperture_y,
-                image_size_.width() - aperture_x * 2,
+      gfx::Rect(aperture_x, aperture_y, image_size_.width() - aperture_x * 2,
                 image_size_.height() - aperture_y * 2));
   shadow_layer_->UpdateNinePatchLayerBorder(
       gfx::Rect(aperture_x, aperture_y, aperture_x * 2, aperture_y * 2));
 }
 
-void Shadow::OnWindowDestroyed(mus::Window* window) {
+void Shadow::OnWindowDestroyed(::mus::Window* window) {
   DCHECK_EQ(window_, window);
   window_ = nullptr;
 }
 
-}  // namespace wm
-}  // namespace mash
+}  // namespace mus
+}  // namespace ash