Use 0.2f opacity only when the shadow animation is applied.

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 "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 {
 
-// Shadow opacity for different styles.
+// The target opacity of shadow animation for different styles.
 const float kActiveShadowOpacity = 1.0f;

[James Cook, 2014/12/11 22:34:04]

I would just delete this constant and inline the use of 1.0f. I think the
existence of this variable (and its name) confused me because it implies that in
the steady-state the assets are drawn with non-1.0 opacity.

[oshima, 2014/12/12 21:23:45]

Done.

 const float kInactiveShadowOpacity = 0.2f;
-const float kSmallShadowOpacity = 1.0f;
 
 // 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;
 
-float GetOpacityForStyle(wm::Shadow::Style style) {
-  switch (style) {
-    case wm::Shadow::STYLE_ACTIVE:
-      return kActiveShadowOpacity;
-    case wm::Shadow::STYLE_INACTIVE:
-      return kInactiveShadowOpacity;
-    case wm::Shadow::STYLE_SMALL:
-      return kSmallShadowOpacity;
-  }
-  return 1.0f;
-}
-
 int GetShadowApertureForStyle(wm::Shadow::Style style) {
   switch (style) {
     case wm::Shadow::STYLE_ACTIVE:
       return kActiveInteriorAperture;
     case wm::Shadow::STYLE_INACTIVE:
       return kInactiveInteriorAperture;
     case wm::Shadow::STYLE_SMALL:
       return kSmallInteriorAperture;
   }
   return 0;
@@ skipping 25 matching lines @@
   style_ = style;
 
   layer_.reset(new ui::Layer(ui::LAYER_NOT_DRAWN));
   shadow_layer_.reset(new ui::Layer(ui::LAYER_NINE_PATCH));
   layer()->Add(shadow_layer_.get());
 
   UpdateImagesForStyle();
   shadow_layer_->set_name("Shadow");
   shadow_layer_->SetVisible(true);
   shadow_layer_->SetFillsBoundsOpaquely(false);
-  shadow_layer_->SetOpacity(GetOpacityForStyle(style_));
+  shadow_layer_->SetOpacity(1.0f);

[oshima, 2014/12/12 21:23:45]

I removed this because 1.0f is default.

 }
 
 void Shadow::SetContentBounds(const gfx::Rect& content_bounds) {
   content_bounds_ = content_bounds;
   UpdateLayerBounds();
 }
 
 void Shadow::SetStyle(Style style) {
   if (style_ == style)
     return;
 
   Style old_style = style_;
   style_ = style;
 
   // Stop waiting for any as yet unfinished implicit animations.
   StopObservingImplicitAnimations();
 
   // If we're switching to or from the small style, don't bother with
   // animations.
   if (style == STYLE_SMALL || old_style == STYLE_SMALL) {
     UpdateImagesForStyle();
-    shadow_layer_->SetOpacity(GetOpacityForStyle(style));
+    shadow_layer_->SetOpacity(1.0f);
     return;
   }
 
   // If we're becoming active, switch images now.  Because the inactive image
   // has a very low opacity the switch isn't noticeable and this approach
   // allows us to use only a single set of shadow images at a time.
   if (style == STYLE_ACTIVE) {
     UpdateImagesForStyle();
     // Opacity was baked into inactive image, start opacity low to match.
     shadow_layer_->SetOpacity(kInactiveShadowOpacity);
@@ skipping 69 matching lines @@
   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,
                 image_size_.height() - aperture_y * 2));
   shadow_layer_->UpdateNinePatchLayerBorder(
       gfx::Rect(aperture_x, aperture_y, aperture_x * 2, aperture_y * 2));
 }
 
 }  // namespace wm