mash: wires up shadows for mash

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"
@@ skipping 34 matching lines @@
     case ui::wm::WINDOW_TYPE_MENU:
     case ui::wm::WINDOW_TYPE_TOOLTIP:
       return ShadowElevation::SMALL;
 
     default:
       break;
   }
   return ShadowElevation::NONE;
 }
 
+// Returns the ShadowElevation for |window|, converting |DEFAULT| to the
+// appropriate ShadowElevation.
+ShadowElevation GetShadowElevationUseDefault(aura::Window* window) {

[msw, 2017/02/15 01:37:29]

optional nit: replace 'Use' with 'Convert', 'Lookup', or similar?

[sky, 2017/02/15 03:58:25]

Done.

+  ShadowElevation elevation = window->GetProperty(kShadowElevationKey);
+  return elevation == ShadowElevation::DEFAULT
+             ? GetDefaultShadowElevationForWindow(window)
+             : elevation;
+}
+
 ShadowElevation GetShadowElevationForActiveState(aura::Window* window) {
   if (IsActiveWindow(window))
     return kActiveNormalShadowElevation;
 
-  return GetShadowElevation(window);
+  return GetShadowElevationUseDefault(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 =
@@ skipping 74 matching lines @@
 
 // static
 ShadowController::Impl* ShadowController::Impl::GetInstance() {
   if (!instance_)
     instance_ = new Impl();
   return instance_;
 }
 
 void ShadowController::Impl::OnWindowInitialized(aura::Window* window) {
   observer_manager_.Add(window);
-  SetShadowElevation(window, GetDefaultShadowElevationForWindow(window));
   HandlePossibleShadowVisibilityChange(window);
 }
 
 void ShadowController::Impl::OnWindowPropertyChanged(aura::Window* window,
                                                      const void* key,
                                                      intptr_t old) {
   if (key == kShadowElevationKey) {
     if (window->GetProperty(kShadowElevationKey) ==
         static_cast<ShadowElevation>(old))
       return;
@@ skipping 26 matching lines @@
                                                aura::Window* gained_active,
                                                aura::Window* lost_active) {
   if (gained_active) {
     Shadow* shadow = GetShadowForWindow(gained_active);
     if (shadow)
       shadow->SetElevation(GetShadowElevationForActiveState(gained_active));
   }
   if (lost_active) {
     Shadow* shadow = GetShadowForWindow(lost_active);
     if (shadow &&
-        GetShadowElevation(lost_active) == kInactiveNormalShadowElevation) {
+        GetShadowElevationUseDefault(lost_active) ==
+            kInactiveNormalShadowElevation) {
       shadow->SetElevation(
           GetShadowElevationForWindowLosingActive(lost_active, gained_active));
     }
   }
 }
 
 bool ShadowController::Impl::ShouldShowShadowForWindow(
     aura::Window* window) const {
   ui::WindowShowState show_state =
       window->GetProperty(aura::client::kShowStateKey);
   if (show_state == ui::SHOW_STATE_FULLSCREEN ||
       show_state == ui::SHOW_STATE_MAXIMIZED) {
     return false;
   }
 
-  return static_cast<int>(GetShadowElevation(window)) > 0;
+  return static_cast<int>(GetShadowElevationUseDefault(window)) > 0;
 }
 
 void ShadowController::Impl::HandlePossibleShadowVisibilityChange(
     aura::Window* window) {
   const bool should_show = ShouldShowShadowForWindow(window);
   Shadow* shadow = GetShadowForWindow(window);
   if (shadow) {
     shadow->SetElevation(GetShadowElevationForActiveState(window));
     shadow->layer()->SetVisible(should_show);
   } else if (should_show && !shadow) {
@@ skipping 39 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