Improve CrOS WM shadow drawing for small windows.

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"
@@ skipping 112 matching lines @@
   UpdateLayerBounds();
 }
 
 void Shadow::RecreateShadowLayer() {
   shadow_layer_.reset(new ui::Layer(ui::LAYER_NINE_PATCH));
   shadow_layer_->set_name("Shadow");
   shadow_layer_->SetVisible(true);
   shadow_layer_->SetFillsBoundsOpaquely(false);
   layer()->Add(shadow_layer_.get());
 
-  const ShadowDetails& details = GetDetailsForElevation(ElevationForStyle());
-  shadow_layer_->UpdateNinePatchLayerImage(details.ninebox_image);
   UpdateLayerBounds();
 }
 
 void Shadow::UpdateLayerBounds() {
-  const ShadowDetails& details = GetDetailsForElevation(ElevationForStyle());
+  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.
+  int size_adjusted_elevation =
+      std::min((std::min(content_bounds_.width(), content_bounds_.height()) -
+                2 * kRoundedCornerRadius) /

[James Cook, 2016/12/19 19:51:49]

nit: wrapping is really ugly here. Maybe try pulling something out into a
constant or other local, or doing the math in multiple lines? Like maybe
max_elevation_for_size or some such?

[Evan Stade, 2016/12/19 21:09:41]

Done.

+                   4,
+               ElevationForStyle());
+  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).
+    gfx::Rect aperture(details.ninebox_image.size());
+    aperture.Inset(blur_region);
+    shadow_layer_->UpdateNinePatchLayerAperture(aperture);
+  }
+  effective_elevation_ = size_adjusted_elevation;
+
   // Shadow margins are negative, so this expands outwards from
   // |content_bounds_|.
   const gfx::Insets margins = gfx::ShadowValue::GetMargin(details.values);
   gfx::Rect new_layer_bounds = content_bounds_;
   new_layer_bounds.Inset(margins);
   gfx::Rect shadow_layer_bounds(new_layer_bounds.size());
 
   // When there's an old shadow fading out, the bounds of layer() have to be
   // big enough to encompass both shadows.
   if (fading_layer_) {
@@ skipping 17 matching lines @@
   }
 
   shadow_layer_->SetBounds(shadow_layer_bounds);
 
   // Occlude the region inside the bounding box. Occlusion uses shadow layer
   // space. See nine_patch_layer.h for more context on what's going on here.
   gfx::Rect occlusion_bounds(shadow_layer_bounds.size());
   occlusion_bounds.Inset(-margins + gfx::Insets(kRoundedCornerRadius));
   shadow_layer_->UpdateNinePatchOcclusion(occlusion_bounds);
 
-  // The border is more or less the same inset as the aperture, but can be no
-  // larger than the shadow layer. When the shadow layer is too small, shrink
-  // the dimensions proportionally.
-  gfx::Insets blur_region = gfx::ShadowValue::GetBlurRegion(details.values) +
-                            gfx::Insets(kRoundedCornerRadius);
-  int border_w = std::min(blur_region.width(), shadow_layer_bounds.width());
-  int border_x = border_w * blur_region.left() / blur_region.width();
-  int border_h = std::min(blur_region.height(), shadow_layer_bounds.height());
-  int border_y = border_h * blur_region.top() / blur_region.height();
+  // The border is the same inset as the aperture.
   shadow_layer_->UpdateNinePatchLayerBorder(
-      gfx::Rect(border_x, border_y, border_w, border_h));
-
-  // 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).
-  gfx::Rect aperture(details.ninebox_image.size());
-  // The insets for the aperture are nominally |blur_region| but we need to
-  // resize them if the contents are too small.
-  // TODO(estade): by cutting out parts of ninebox, we lose the smooth
-  // horizontal or vertical transition. This isn't very noticeable, but we may
-  // need to address it by using a separate shadow layer for each ShadowValue,
-  // by adjusting the shadow for very small windows, or other means.
-  aperture.Inset(gfx::Insets(border_y, border_x, border_h - border_y,
-                             border_w - border_x));
-  shadow_layer_->UpdateNinePatchLayerAperture(aperture);
+      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