Update voice interaction icon shadow

ash/shelf/voice_interaction_overlay.cc

 // Copyright 2017 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/shelf/voice_interaction_overlay.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 21 matching lines @@
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/scoped_canvas.h"
+#include "ui/gfx/skia_paint_util.h"
 #include "ui/views/animation/flood_fill_ink_drop_ripple.h"
 #include "ui/views/animation/ink_drop_impl.h"
 #include "ui/views/animation/ink_drop_mask.h"
 #include "ui/views/painter.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 constexpr int kFullExpandDurationMs = 650;
 constexpr int kFullRetractDurationMs = 300;
@@ skipping 14 matching lines @@
 constexpr float kIconSizeDip = 24.f;
 constexpr float kIconOffsetDip = 56.f;
 constexpr float kIconOpacity = 1.f;
 constexpr int kIconBurstDurationMs = 100;
 
 constexpr float kBackgroundInitSizeDip = 48.f;
 constexpr float kBackgroundStartSizeDip = 10.f;
 constexpr float kBackgroundSizeDip = 48.f;
 constexpr int kBackgroundStartDelayMs = 100;
 constexpr int kBackgroundOpacityDurationMs = 200;
-constexpr float kBackgroundShadowSizeDip = 12;
-
-class CircleImageSource : public gfx::CanvasImageSource {
- public:
-  CircleImageSource(float radius, float padding)
-      : CanvasImageSource(
-            gfx::Size((radius + padding) * 2, (radius + padding) * 2),
-            false),
-        radius_(radius),
-        padding_(padding) {}
-  ~CircleImageSource() override {}
-
- private:
-  void Draw(gfx::Canvas* canvas) override {
-    cc::PaintFlags flags;
-    flags.setColor(SK_ColorWHITE);
-    flags.setAntiAlias(true);
-    flags.setStyle(cc::PaintFlags::kFill_Style);
-    canvas->DrawCircle(gfx::PointF(radius_ + padding_, radius_ + padding_),
-                       radius_, flags);
-  }
-
-  float radius_;
-  float padding_;
-
-  DISALLOW_COPY_AND_ASSIGN(CircleImageSource);
-};
+constexpr float kBackgroundShadowElevationDip = 24.f;
 
 class VoiceInteractionIconBackground : public ui::Layer,
                                        public ui::LayerDelegate {
  public:
-  VoiceInteractionIconBackground()
-      : Layer(ui::LAYER_NOT_DRAWN),
-        shadow_values_(1,
-                       gfx::ShadowValue(gfx::Vector2d(0, 0),
-                                        kBackgroundShadowSizeDip,
-                                        SkColorSetARGB(0x54, 0, 0, 0))) {
+  VoiceInteractionIconBackground() : Layer(ui::LAYER_NOT_DRAWN) {
     set_name("VoiceInteractionOverlay:BACKGROUND_LAYER");
     SetBounds(gfx::Rect(0, 0, kBackgroundInitSizeDip, kBackgroundInitSizeDip));
     SetFillsBoundsOpaquely(false);
     SetMasksToBounds(false);
 
+    shadow_values_ =
+        gfx::ShadowValue::MakeMdShadowValues(kBackgroundShadowElevationDip);
+    gfx::Insets shadow_margin = gfx::ShadowValue::GetMargin(shadow_values_);

[oshima, 2017/06/21 18:14:52]

nit: const

[xc, 2017/06/21 18:50:59]

Done.

+
     shadow_layer_.reset(new ui::Layer());
     shadow_layer_->set_delegate(this);
     shadow_layer_->SetFillsBoundsOpaquely(false);
-    shadow_layer_->SetBounds(
-        gfx::Rect(-kBackgroundShadowSizeDip, -kBackgroundShadowSizeDip,
-                  kBackgroundInitSizeDip + kBackgroundShadowSizeDip * 2,
-                  kBackgroundInitSizeDip + kBackgroundShadowSizeDip * 2));
+    shadow_layer_->SetBounds({shadow_margin.left(), shadow_margin.top(),
+                              kBackgroundInitSizeDip - shadow_margin.width(),
+                              kBackgroundInitSizeDip - shadow_margin.height()});
     Add(shadow_layer_.get());
   }
   ~VoiceInteractionIconBackground() override{};
 
  private:
   void OnPaintLayer(const ui::PaintContext& context) override {
     // Radius is based on the parent layer size, the shadow layer is expanded
     // to make room for the shadow.
     float radius = size().width() / 2.f;
-    CircleImageSource* circle_image =
-        new CircleImageSource(radius, kBackgroundShadowSizeDip);
-    gfx::ImageSkia background_with_shadow =
-        gfx::ImageSkiaOperations::CreateImageWithDropShadow(
-            gfx::ImageSkia(circle_image, circle_image->size()), shadow_values_);
 
-    ui::PaintRecorder recorder(context, background_with_shadow.size());
+    ui::PaintRecorder recorder(context, shadow_layer_->size());
     gfx::Canvas* canvas = recorder.canvas();
-    float shadow_offset =
-        (shadow_layer_->size().width() - background_with_shadow.width()) / 2.f;
-    canvas->DrawImageInt(background_with_shadow, shadow_offset, shadow_offset);
+
+    cc::PaintFlags flags;
+    flags.setColor(SK_ColorWHITE);
+    flags.setAntiAlias(true);
+    flags.setStyle(cc::PaintFlags::kFill_Style);
+    flags.setLooper(gfx::CreateShadowDrawLooper(shadow_values_));
+    gfx::Rect shadow_bounds = shadow_layer_->bounds();
+    canvas->DrawCircle({radius - shadow_bounds.x(), radius - shadow_bounds.y()},
+                       radius, flags);
   }
 
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
   gfx::ShadowValues shadow_values_;
 
   std::unique_ptr<ui::Layer> shadow_layer_;
 
@@ skipping 296 matching lines @@
     settings.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kFullRetractDurationMs));
     settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
 
     background_layer_->SetTransform(transform);
     background_layer_->SetOpacity(0);
   }
 }
 
 }  // namespace ash