Update ash phantom window aesthetics.

ui/wm/core/shadow_controller.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_controller.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/scoped_observer.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/env_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/class_property.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/wm/core/shadow.h"
-#include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 using std::make_pair;
 
 DECLARE_UI_CLASS_PROPERTY_TYPE(::wm::Shadow*);
 DEFINE_OWNED_UI_CLASS_PROPERTY_KEY(::wm::Shadow, kShadowLayerKey, nullptr);
 
 namespace wm {
 
 namespace {
 
-constexpr ShadowElevation kActiveNormalShadowElevation = ShadowElevation::LARGE;
 constexpr ShadowElevation kInactiveNormalShadowElevation =
     ShadowElevation::MEDIUM;
 
 ShadowElevation GetDefaultShadowElevationForWindow(aura::Window* window) {
   switch (window->type()) {
     case ui::wm::WINDOW_TYPE_NORMAL:
     case ui::wm::WINDOW_TYPE_PANEL:
       return kInactiveNormalShadowElevation;
 
     case ui::wm::WINDOW_TYPE_MENU:
@@ skipping 14 matching lines @@
              ? GetDefaultShadowElevationForWindow(window)
              : elevation;
 }
 
 ShadowElevation GetShadowElevationForActiveState(aura::Window* window) {
   ShadowElevation elevation = window->GetProperty(kShadowElevationKey);
   if (elevation != ShadowElevation::DEFAULT)
     return elevation;
 
   if (IsActiveWindow(window))
-    return kActiveNormalShadowElevation;
+    return ShadowController::kActiveNormalShadowElevation;
 
   return GetDefaultShadowElevationForWindow(window);
 }
 
 // Returns the shadow style to be applied to |losing_active| when it is losing
 // active to |gaining_active|. |gaining_active| may be of a type that hides when
 // inactive, and as such we do not want to render |losing_active| as inactive.
 ShadowElevation GetShadowElevationForWindowLosingActive(
     aura::Window* losing_active,
     aura::Window* gaining_active) {
   if (gaining_active && aura::client::GetHideOnDeactivate(gaining_active)) {
     aura::Window::Windows::const_iterator it =
         std::find(GetTransientChildren(losing_active).begin(),
                   GetTransientChildren(losing_active).end(),
                   gaining_active);
     if (it != GetTransientChildren(losing_active).end())
-      return kActiveNormalShadowElevation;
+      return ShadowController::kActiveNormalShadowElevation;
   }
   return kInactiveNormalShadowElevation;
 }
 
 }  // namespace
 
 // ShadowController::Impl ------------------------------------------------------
 
 // Real implementation of the ShadowController. ShadowController observes
 // ActivationChangeObserver, which are per ActivationClient, where as there is
@@ skipping 182 matching lines @@
   activation_client_->RemoveObserver(this);
 }
 
 void ShadowController::OnWindowActivated(ActivationReason reason,
                                          aura::Window* gained_active,
                                          aura::Window* lost_active) {
   impl_->OnWindowActivated(reason, gained_active, lost_active);
 }
 
 }  // namespace wm