Replace WM shadow types (on/off) and styles (small/inactive/active)

ui/wm/core/shadow.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 "ui/wm/core/shadow.h"
 
 #include "base/lazy_instance.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/image/image_skia_operations.h"
+#include "ui/wm/core/shadow_types.h"
 
 namespace wm {
 
 namespace {
 
 // Rounded corners are overdrawn on top of the window's content layer,
 // we need to exclude them from the occlusion area.
 const int kRoundedCornerRadius = 2;
 
 // Duration for opacity animation in milliseconds.
@@ skipping 33 matching lines @@
   // To see what this looks like for elevation 24, try this CSS:
   //   box-shadow: 0 24px 48px rgba(0, 0, 0, .24),
   //               0 0 24px rgba(0, 0, 0, .12);
   shadow->ninebox_image = gfx::ImageSkiaOperations::CreateShadowNinebox(
       shadow->values, kRoundedCornerRadius);
   return *shadow;
 }
 
 }  // namespace
 
-Shadow::Shadow() {}
+Shadow::Shadow() : desired_elevation_(ShadowElevation::NONE) {}
 
 Shadow::~Shadow() {}
 
-void Shadow::Init(Style style) {
-  style_ = style;
+void Shadow::Init(ShadowElevation elevation) {
+  desired_elevation_ = elevation;
   layer_.reset(new ui::Layer(ui::LAYER_NOT_DRAWN));
   RecreateShadowLayer();
 }
 
 void Shadow::SetContentBounds(const gfx::Rect& content_bounds) {
   // When the window moves but doesn't change size, this is a no-op. (The
   // origin stays the same in this case.)
   if (content_bounds == content_bounds_)
     return;
 
   content_bounds_ = content_bounds;
   UpdateLayerBounds();
 }
 
-void Shadow::SetStyle(Style style) {
-  if (style_ == style)
+void Shadow::SetElevation(ShadowElevation elevation) {
+  if (desired_elevation_ == elevation)
     return;
 
-  style_ = style;
+  desired_elevation_ = elevation;
 
   // Stop waiting for any as yet unfinished implicit animations.
   StopObservingImplicitAnimations();
 
   // The old shadow layer is the new fading out layer.
   DCHECK(shadow_layer_);
   fading_layer_ = std::move(shadow_layer_);
   RecreateShadowLayer();
   shadow_layer_->SetOpacity(0.f);
 
@@ skipping 29 matching lines @@
   shadow_layer_->SetFillsBoundsOpaquely(false);
   layer()->Add(shadow_layer_.get());
 
   UpdateLayerBounds();
 }
 
 void Shadow::UpdateLayerBounds() {
   if (content_bounds_.IsEmpty())
     return;
 
-  // The elevation depends on the style, but the ninebox assumption breaks down
-  // when the window is too small. The height/width of |blur_region| will be
-  // 4 * elevation (see GetDetailsForElevation), so cap elevation at the most we
-  // can handle.
+  // The ninebox assumption breaks down when the window is too small for the
+  // desired elevation. The height/width of |blur_region| will be 4 * elevation
+  // (see GetDetailsForElevation), so cap elevation at the most we can handle.
   const int smaller_dimension =
       std::min(content_bounds_.width(), content_bounds_.height());
-  const int size_adjusted_elevation = std::min(
-      (smaller_dimension - 2 * kRoundedCornerRadius) / 4, ElevationForStyle());
+  const int size_adjusted_elevation =
+      std::min((smaller_dimension - 2 * kRoundedCornerRadius) / 4,
+               static_cast<int>(desired_elevation_));
   const ShadowDetails& details =
       GetDetailsForElevation(size_adjusted_elevation);
   gfx::Insets blur_region = gfx::ShadowValue::GetBlurRegion(details.values) +
                             gfx::Insets(kRoundedCornerRadius);
   if (size_adjusted_elevation != effective_elevation_) {
     shadow_layer_->UpdateNinePatchLayerImage(details.ninebox_image);
     // The ninebox grid is defined in terms of the image size. The shadow blurs
     // in both inward and outward directions from the edge of the contents, so
     // the aperture goes further inside the image than the shadow margins (which
     // represent exterior blur).
@@ skipping 39 matching lines @@
   gfx::Rect occlusion_bounds(shadow_layer_bounds.size());
   occlusion_bounds.Inset(-margins + gfx::Insets(kRoundedCornerRadius));
   shadow_layer_->UpdateNinePatchOcclusion(occlusion_bounds);
 
   // The border is the same inset as the aperture.
   shadow_layer_->UpdateNinePatchLayerBorder(
       gfx::Rect(blur_region.left(), blur_region.top(), blur_region.width(),
                 blur_region.height()));
 }
 
-int Shadow::ElevationForStyle() {
-  switch (style_) {
-    case STYLE_ACTIVE:
-      return 24;
-    case STYLE_INACTIVE:
-      return 8;
-    case STYLE_SMALL:
-      return 6;
-  }
-  NOTREACHED();
-  return 0;
-}
-
 }  // namespace wm