Ash: Make window resize shadow extend beneath window it's attached to.

ash/wm/resize_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 "ash/wm/resize_shadow.h"
 
 #include "base/lazy_instance.h"
 #include "base/time/time.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/canvas_image_source.h"
 
 namespace {
 
 // The width of the resize shadow that appears on the hovered edge of the
 // window.
 constexpr int kVisualThickness = 8;
 
+// The corner radius of the resize shadow, which not coincidentally matches
+// the corner radius of the actual window.

[varkha, 2017/04/18 22:31:58]

Should one just be equal to the other, even if you keep both constants for self
documenting the code?

[Evan Stade, 2017/04/19 13:23:10]

Arguably. I actually think it's easier to read like this because it's hard to
mess up reading "2" whereas kCornerRadiusOfFoo could require you to read every
word carefully.

+static constexpr int kCornerRadiusOfResizeShadow = 2;
+static constexpr int kCornerRadiusOfWindow = 2;
+
 // This class simply draws a roundrect. The layout and tiling is handled by
 // ResizeShadow and NinePatchLayer.
 class ResizeShadowImageSource : public gfx::CanvasImageSource {
  public:
   ResizeShadowImageSource()
       : gfx::CanvasImageSource(gfx::Size(kImageSide, kImageSide),
                                false /* is opaque */) {}
 
   ~ResizeShadowImageSource() override {}
 
   // gfx::CanvasImageSource:
   void Draw(gfx::Canvas* canvas) override {
     cc::PaintFlags paint;
     paint.setAntiAlias(true);
     paint.setColor(SK_ColorBLACK);
-    canvas->DrawRoundRect(gfx::RectF(gfx::SizeF(size())), kCornerRadius, paint);
+    canvas->DrawRoundRect(gfx::RectF(gfx::SizeF(size())),
+                          kCornerRadiusOfResizeShadow, paint);
   }
 
  private:
-  static constexpr int kCornerRadius = 2;
-  static constexpr int kImageSide = 2 * kVisualThickness + 1;
+  // The image has to have enough space to depict the visual thickness (left and
+  // right) plus an inset for extending beneath the window's rounded corner plus
+  // one pixel for the center of the nine patch.
+  static constexpr int kImageSide =
+      2 * (kVisualThickness + kCornerRadiusOfWindow) + 1;
 
   DISALLOW_COPY_AND_ASSIGN(ResizeShadowImageSource);
 };
 
 base::LazyInstance<std::unique_ptr<gfx::ImageSkia>>::Leaky g_shadow_image =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace ash {
 
 ResizeShadow::ResizeShadow(aura::Window* window)
     : window_(window), last_hit_test_(HTNOWHERE) {
   window_->AddObserver(this);
 
   // Use a NinePatchLayer to tile the shadow image (which is simply a
   // roundrect).
   layer_.reset(new ui::Layer(ui::LAYER_NINE_PATCH));
   layer_->set_name("WindowResizeShadow");
   layer_->SetFillsBoundsOpaquely(false);
   layer_->SetOpacity(0.f);
   layer_->SetVisible(false);
 
   if (!g_shadow_image.Get()) {
     auto* source = new ResizeShadowImageSource();
     g_shadow_image.Get().reset(new gfx::ImageSkia(source, source->size()));
   }
   layer_->UpdateNinePatchLayerImage(*g_shadow_image.Get());
   gfx::Rect aperture(g_shadow_image.Get()->size());
-  constexpr gfx::Insets kApertureInsets(kVisualThickness);
+  constexpr gfx::Insets kApertureInsets(kVisualThickness +
+                                        kCornerRadiusOfWindow);
   aperture.Inset(kApertureInsets);
   layer_->UpdateNinePatchLayerAperture(aperture);
   layer_->UpdateNinePatchLayerBorder(
       gfx::Rect(kApertureInsets.left(), kApertureInsets.top(),
                 kApertureInsets.width(), kApertureInsets.height()));
 
   ReparentLayer();
 }
 
 ResizeShadow::~ResizeShadow() {
@@ skipping 61 matching lines @@
     constexpr int kShadowFadeOutDurationMs = 100;
     settings.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kShadowFadeOutDurationMs));
   }
   constexpr float kShadowTargetOpacity = 0.5f;
   layer_->SetOpacity(visible ? kShadowTargetOpacity : 0.f);
   layer_->SetVisible(visible);
 }
 
 }  // namespace ash