Replace WM shadow types (on/off) and styles (small/inactive/active)

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 14 matching lines @@
 
 using std::make_pair;
 
 DECLARE_WINDOW_PROPERTY_TYPE(wm::Shadow*);
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(wm::Shadow, kShadowLayerKey, nullptr);
 
 namespace wm {
 
 namespace {
 
-ShadowType GetShadowTypeFromWindow(aura::Window* window) {
+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:
     case ui::wm::WINDOW_TYPE_TOOLTIP:
-      return SHADOW_TYPE_RECTANGULAR;
+      return ShadowElevation::SMALL;
+
     default:
       break;
   }
-  return SHADOW_TYPE_NONE;
+  return ShadowElevation::NONE;
 }
 
-Shadow::Style GetShadowStyleForWindow(aura::Window* window) {
-  switch (window->type()) {
-    case ui::wm::WINDOW_TYPE_MENU:
-    case ui::wm::WINDOW_TYPE_TOOLTIP:
-      return Shadow::STYLE_SMALL;
+ShadowElevation GetShadowElevationForActiveState(aura::Window* window) {
+  if (IsActiveWindow(window))
+    return kActiveNormalShadowElevation;
 
-    // System tray bubbles render like active windows. TODO(estade): this
-    // mechanism will need to be revisited for applying WM shadows to other
-    // types of bubbles which don't want to render such large shadows.
-    case ui::wm::WINDOW_TYPE_POPUP:
-      return Shadow::STYLE_ACTIVE;
-
-    default:
-      return IsActiveWindow(window) ? Shadow::STYLE_ACTIVE
-                                    : Shadow::STYLE_INACTIVE;
-  }
+  return GetShadowElevation(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.
-Shadow::Style GetShadowStyleForWindowLosingActive(
+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 Shadow::STYLE_ACTIVE;
+      return kActiveNormalShadowElevation;
   }
-  return Shadow::STYLE_INACTIVE;
+  return kInactiveNormalShadowElevation;
 }
 
 }  // namespace
 
 // ShadowController::Impl ------------------------------------------------------
 
 // Real implementation of the ShadowController. ShadowController observes
 // ActivationChangeObserver, which are per ActivationClient, where as there is
 // only a single Impl (as it observes all window creation by way of an
 // EnvObserver).
@@ skipping 25 matching lines @@
   ~Impl() override;
 
   // Forwarded from ShadowController.
   void OnWindowActivated(ActivationReason reason,
                          aura::Window* gained_active,
                          aura::Window* lost_active);
 
   // Checks if |window| is visible and contains a property requesting a shadow.
   bool ShouldShowShadowForWindow(aura::Window* window) const;
 
-  // Updates the shadow styles for windows when activation changes.
+  // Updates the shadow for windows when activation changes.
   void HandleWindowActivationChange(aura::Window* gaining_active,
                                     aura::Window* losing_active);
 
   // Shows or hides |window|'s shadow as needed (creating the shadow if
   // necessary).
   void HandlePossibleShadowVisibilityChange(aura::Window* window);
 
   // Creates a new shadow for |window| and stores it with the |kShadowLayerKey|
   // key.
   // The shadow's bounds are initialized and it is added to the window's layer.
@@ skipping 11 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);
-  SetShadowType(window, GetShadowTypeFromWindow(window));
+  SetShadowElevation(window, GetDefaultShadowElevationForWindow(window));
   HandlePossibleShadowVisibilityChange(window);
 }
 
 void ShadowController::Impl::OnWindowPropertyChanged(aura::Window* window,
                                                      const void* key,
                                                      intptr_t old) {
-  if (key == kShadowTypeKey) {
-    if (window->GetProperty(kShadowTypeKey) == static_cast<ShadowType>(old))
+  if (key == kShadowElevationKey) {
+    if (window->GetProperty(kShadowElevationKey) ==
+        static_cast<ShadowElevation>(old))
       return;
   } else if (key == aura::client::kShowStateKey) {
     if (window->GetProperty(aura::client::kShowStateKey) ==
         static_cast<ui::WindowShowState>(old)) {
       return;
     }
   } else {
     return;
   }
   HandlePossibleShadowVisibilityChange(window);
@@ skipping 12 matching lines @@
   window->ClearProperty(kShadowLayerKey);
   observer_manager_.Remove(window);
 }
 
 void ShadowController::Impl::OnWindowActivated(ActivationReason reason,
                                                aura::Window* gained_active,
                                                aura::Window* lost_active) {
   if (gained_active) {
     Shadow* shadow = GetShadowForWindow(gained_active);
     if (shadow)
-      shadow->SetStyle(GetShadowStyleForWindow(gained_active));
+      shadow->SetElevation(GetShadowElevationForActiveState(gained_active));
   }
   if (lost_active) {
     Shadow* shadow = GetShadowForWindow(lost_active);
     if (shadow &&
-        GetShadowStyleForWindow(lost_active) == Shadow::STYLE_INACTIVE) {
-      shadow->SetStyle(GetShadowStyleForWindowLosingActive(lost_active,
-                                                           gained_active));
+        GetShadowElevation(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 SHADOW_TYPE_NONE;
+    return false;
   }
 
-  const ShadowType type = GetShadowType(window);
-  switch (type) {
-    case SHADOW_TYPE_NONE:
-      return false;
-    case SHADOW_TYPE_RECTANGULAR:
-      return true;
-    default:
-      NOTREACHED() << "Unknown shadow type " << type;
-      return false;
-  }
+  return static_cast<int>(GetShadowElevation(window)) > 0;
 }
 
 void ShadowController::Impl::HandlePossibleShadowVisibilityChange(
     aura::Window* window) {
   const bool should_show = ShouldShowShadowForWindow(window);
   Shadow* shadow = GetShadowForWindow(window);
   if (shadow) {
-    shadow->SetStyle(GetShadowStyleForWindow(window));
+    shadow->SetElevation(GetShadowElevationForActiveState(window));
     shadow->layer()->SetVisible(should_show);
   } else if (should_show && !shadow) {
     CreateShadowForWindow(window);
   }
 }
 
 void ShadowController::Impl::CreateShadowForWindow(aura::Window* window) {
   Shadow* shadow = new Shadow();
   window->SetProperty(kShadowLayerKey, shadow);
-  shadow->Init(GetShadowStyleForWindow(window));
+  shadow->Init(GetShadowElevationForActiveState(window));
   shadow->SetContentBounds(gfx::Rect(window->bounds().size()));
   shadow->layer()->SetVisible(ShouldShowShadowForWindow(window));
   window->layer()->Add(shadow->layer());
 }
 
 ShadowController::Impl::Impl()
     : observer_manager_(this) {
   aura::Env::GetInstance()->AddObserver(this);
 }
 
@@ skipping 21 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