exo: Add initial support for service side decorations.

components/exo/shell_surface.cc

 // Copyright 2015 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 "components/exo/shell_surface.h"
 
 #include <algorithm>
 
 #include "ash/aura/wm_window_aura.h"
+#include "ash/common/frame/custom_frame_view_ash.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/window_state_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 10 matching lines @@
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/gfx/path.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_observer.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/shadow.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/shadow_types.h"
+#include "ui/wm/core/window_animations.h"
 #include "ui/wm/core/window_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/chromeos_sounds.h"
 #endif
 
 namespace exo {
 namespace {
 
 // This is a struct for accelerator keys used to close ShellSurfaces.
@@ skipping 43 matching lines @@
 
   // Overridden from aura::WindowTargeter:
   bool EventLocationInsideBounds(aura::Window* window,
                                  const ui::LocatedEvent& event) const override {
     Surface* surface = ShellSurface::GetMainSurface(window);
     if (!surface)
       return false;
 
     gfx::Point local_point = event.location();
 
+    if (window->parent()) {
+      aura::Window::ConvertPointToTarget(window->parent(), window,
+                                         &local_point);
+    }
+
+    int component = widget_->non_client_view()->NonClientHitTest(local_point);
+    if (component != HTNOWHERE && component != HTCLIENT)
+      return true;
+
     // If there is an underlay, test against it's bounds instead since it will
     // be equal or larger than the surface's bounds.
     aura::Window* shadow_underlay =
         static_cast<ShellSurface*>(
             widget_->widget_delegate()->GetContentsView())
             ->shadow_underlay();
     if (shadow_underlay) {
-      if (window->parent())
-        aura::Window::ConvertPointToTarget(window->parent(), shadow_underlay,
-                                           &local_point);
+      aura::Window::ConvertPointToTarget(window, shadow_underlay, &local_point);
       return gfx::Rect(shadow_underlay->layer()->size()).Contains(local_point);
     }
 
-    if (window->parent())
-      aura::Window::ConvertPointToTarget(window->parent(), window,
-                                         &local_point);
-
     aura::Window::ConvertPointToTarget(window, surface->window(), &local_point);
     return surface->HitTestRect(gfx::Rect(local_point, gfx::Size(1, 1)));
   }
 
   ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
                                       ui::Event* event) override {
     aura::Window* window = static_cast<aura::Window*>(root);
     Surface* surface = ShellSurface::GetMainSurface(window);
 
     // Send events which are outside of the surface's bounds to the underlay.
     aura::Window* shadow_underlay =
         static_cast<ShellSurface*>(
             widget_->widget_delegate()->GetContentsView())
             ->shadow_underlay();
     if (surface && event->IsLocatedEvent() && shadow_underlay) {
       gfx::Point local_point = event->AsLocatedEvent()->location();
-      aura::Window::ConvertPointToTarget(window, surface->window(),
-                                         &local_point);
-      if (!surface->HitTestRect(gfx::Rect(local_point, gfx::Size(1, 1))))
+      int component = widget_->non_client_view()->NonClientHitTest(local_point);
+      if (component == HTNOWHERE)
         return shadow_underlay;
     }
     return aura::WindowTargeter::FindTargetForEvent(root, event);
   }
 
  private:
   views::Widget* const widget_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomWindowTargeter);
 };
@@ skipping 177 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellSurface, public:
 
 DEFINE_LOCAL_WINDOW_PROPERTY_KEY(Surface*, kMainSurfaceKey, nullptr)
 
 ShellSurface::ShellSurface(Surface* surface,
                            ShellSurface* parent,
                            const gfx::Rect& initial_bounds,
                            bool activatable,
+                           bool can_minimize,
                            int container)
     : widget_(nullptr),
       surface_(surface),
       parent_(parent ? parent->GetWidget()->GetNativeWindow() : nullptr),
       initial_bounds_(initial_bounds),
       activatable_(activatable),
+      can_minimize_(can_minimize),
       container_(container) {
   WMHelper::GetInstance()->AddActivationObserver(this);
   surface_->SetSurfaceDelegate(this);
   surface_->AddSurfaceObserver(this);
   surface_->window()->Show();
   set_owned_by_client();
   if (parent_)
     parent_->AddObserver(this);
 }
 
 ShellSurface::ShellSurface(Surface* surface)
     : ShellSurface(surface,
                    nullptr,
                    gfx::Rect(),
                    true,
+                   true,
                    ash::kShellWindowId_DefaultContainer) {}
 
 ShellSurface::~ShellSurface() {
   DCHECK(!scoped_configure_);
   if (resizer_)
     EndDrag(false /* revert */);
   if (widget_) {
     ash::wm::GetWindowState(widget_->GetNativeWindow())->RemoveObserver(this);
     widget_->GetNativeWindow()->RemoveObserver(this);
     if (widget_->IsVisible())
@@ skipping 204 matching lines @@
                geometry.ToString());
 
   if (geometry.IsEmpty()) {
     DLOG(WARNING) << "Surface geometry must be non-empty";
     return;
   }
 
   pending_geometry_ = geometry;
 }
 
-void ShellSurface::SetRectangularShadow(const gfx::Rect& content_bounds) {
-  TRACE_EVENT1("exo", "ShellSurface::SetRectangularShadow", "content_bounds",
-               content_bounds.ToString());
+void ShellSurface::SetRectangularShadow(bool enabled) {
+  TRACE_EVENT1("exo", "ShellSurface::SetRectangularShadow", "enabled", enabled);
+
+  shadow_enabled_ = enabled;
+}
+
+void ShellSurface::SetRectangularShadowContentBounds(
+    const gfx::Rect& content_bounds) {
+  TRACE_EVENT1("exo", "ShellSurface::SetRectangularShadowContentBounds",
+               "content_bounds", content_bounds.ToString());
 
   shadow_content_bounds_ = content_bounds;
 }
 
 void ShellSurface::SetRectangularShadowBackgroundOpacity(float opacity) {
   TRACE_EVENT1("exo", "ShellSurface::SetRectangularShadowBackgroundOpacity",
                "opacity", opacity);
 
-  rectangular_shadow_background_opacity_ = opacity;
+  shadow_background_opacity_ = opacity;
+}
+
+void ShellSurface::SetFrame(bool enabled) {
+  TRACE_EVENT1("exo", "ShellSurface::SetFrame", "enabled", enabled);
+
+  frame_enabled_ = enabled;
 }
 
 void ShellSurface::SetScale(double scale) {
   TRACE_EVENT1("exo", "ShellSurface::SetScale", "scale", scale);
 
   if (scale <= 0.0) {
     DLOG(WARNING) << "Surface scale must be greater than 0";
     return;
   }
 
   pending_scale_ = scale;
 }
 
 void ShellSurface::SetTopInset(int height) {
   TRACE_EVENT1("exo", "ShellSurface::SetTopInset", "height", height);
 
   pending_top_inset_height_ = height;
 }
 
 void ShellSurface::SetOrigin(const gfx::Point& origin) {
   TRACE_EVENT1("exo", "ShellSurface::SetOrigin", "origin", origin.ToString());
 
   initial_bounds_ = gfx::Rect(origin, gfx::Size(1, 1));
 }
 
-void ShellSurface::SetActivatable(bool activatable) {
-  TRACE_EVENT1("exo", "ShellSurface::SetActivatable", "activatable",
-               activatable);
+void ShellSurface::SetContainer(int container) {
+  TRACE_EVENT1("exo", "ShellSurface::SetContainer", "container", container);
 
-  activatable_ = activatable;
+  container_ = container;
 }
 
 // static
 void ShellSurface::SetMainSurface(aura::Window* window, Surface* surface) {
   window->SetProperty(kMainSurfaceKey, surface);
 }
 
 // static
 Surface* ShellSurface::GetMainSurface(const aura::Window* window) {
   return window->GetProperty(kMainSurfaceKey);
@@ skipping 36 matching lines @@
     UpdateWidgetBounds();
     UpdateShadow();
 
     // Apply new top inset height.
     if (pending_top_inset_height_ != top_inset_height_) {
       widget_->GetNativeWindow()->SetProperty(aura::client::kTopViewInset,
                                               pending_top_inset_height_);
       top_inset_height_ = pending_top_inset_height_;
     }
 
-    gfx::Point surface_origin = GetSurfaceOrigin();
-
     // System modal container is used by clients to implement overlay
     // windows using a single ShellSurface instance.  If hit-test
     // region is empty, then it is non interactive window and won't be
     // activated.
     if (container_ == ash::kShellWindowId_SystemModalContainer) {
-      gfx::Rect hit_test_bounds =
-          surface_->GetHitTestBounds() + surface_origin.OffsetFromOrigin();
+      gfx::Rect hit_test_bounds = surface_->GetHitTestBounds();
 
       // Prevent window from being activated when hit test bounds are empty.
       bool activatable = activatable_ && !hit_test_bounds.IsEmpty();
       if (activatable != CanActivate()) {
         set_can_activate(activatable);
         // Activate or deactivate window if activation state changed.
         if (activatable)
           wm::ActivateWindow(widget_->GetNativeWindow());
         else if (widget_->IsActive())
           wm::DeactivateWindow(widget_->GetNativeWindow());
       }
     }
 
+    gfx::Rect client_view_bounds =
+        widget_->non_client_view()->frame_view()->GetBoundsForClientView();
+
     // Update surface bounds.
     surface_->window()->SetBounds(
-        gfx::Rect(surface_origin, surface_->window()->layer()->size()));
+        gfx::Rect(GetSurfaceOrigin() + client_view_bounds.OffsetFromOrigin(),
+                  surface_->window()->layer()->size()));
 
     // Update surface scale.
     if (pending_scale_ != scale_) {
       gfx::Transform transform;
       DCHECK_NE(pending_scale_, 0.0);
       transform.Scale(1.0 / pending_scale_, 1.0 / pending_scale_);
       surface_->window()->SetTransform(transform);
       scale_ = pending_scale_;
     }
 
@@ skipping 37 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // views::WidgetDelegate overrides:
 
 bool ShellSurface::CanResize() const {
   return initial_bounds_.IsEmpty();
 }
 
 bool ShellSurface::CanMaximize() const {
   // Shell surfaces in system modal container cannot be maximized.
-  return container_ != ash::kShellWindowId_SystemModalContainer;
+  if (container_ == ash::kShellWindowId_SystemModalContainer)
+    return false;
+
+  // Non-transient shell surfaces can be maximized.
+  return !parent_;
 }
 
 bool ShellSurface::CanMinimize() const {
-  // Shell surfaces in system modal container cannot be minimized.
-  return container_ != ash::kShellWindowId_SystemModalContainer;
+  return can_minimize_;
 }
 
 base::string16 ShellSurface::GetWindowTitle() const {
   return title_;
 }
 
 void ShellSurface::WindowClosing() {
   if (resizer_)
     EndDrag(true /* revert */);
   SetEnabled(false);
   widget_ = nullptr;
   shadow_overlay_ = nullptr;
   shadow_underlay_ = nullptr;
 }
 
 views::Widget* ShellSurface::GetWidget() {
   return widget_;
 }
 
 const views::Widget* ShellSurface::GetWidget() const {
   return widget_;
 }
 
 views::View* ShellSurface::GetContentsView() {
   return this;
 }
 
 views::NonClientFrameView* ShellSurface::CreateNonClientFrameView(
     views::Widget* widget) {
+  aura::Window* window = widget_->GetNativeWindow();
+  ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
+  // Set delegate for handling of fullscreening.
+  window_state->SetDelegate(std::unique_ptr<ash::wm::WindowStateDelegate>(
+      new CustomWindowStateDelegate(widget_)));
+
+  if (frame_enabled_)
+    return new ash::CustomFrameViewAsh(widget);
+
   return new CustomFrameView(widget);
 }
 
 bool ShellSurface::WidgetHasHitTestMask() const {
   return surface_ ? surface_->HasHitTestMask() : false;
 }
 
 void ShellSurface::GetWidgetHitTestMask(gfx::Path* mask) const {
   DCHECK(WidgetHasHitTestMask());
   surface_->GetHitTestMask(mask);
   gfx::Point origin = surface_->window()->bounds().origin();
   mask->offset(SkIntToScalar(origin.x()), SkIntToScalar(origin.y()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // views::Views overrides:
 
 gfx::Size ShellSurface::GetPreferredSize() const {
   if (!geometry_.IsEmpty())
     return geometry_.size();
 
   return surface_ ? surface_->window()->layer()->size() : gfx::Size();
 }
 
+gfx::Size ShellSurface::GetMinimumSize() const {
+  return gfx::Size(1, 1);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ash::wm::WindowStateObserver overrides:
 
 void ShellSurface::OnPreWindowStateTypeChange(
     ash::wm::WindowState* window_state,
     ash::wm::WindowStateType old_type) {
   ash::wm::WindowStateType new_type = window_state->GetStateType();
   if (ash::wm::IsMaximizedOrFullscreenOrPinnedWindowStateType(old_type) ||
       ash::wm::IsMaximizedOrFullscreenOrPinnedWindowStateType(new_type)) {
     // When transitioning in/out of maximized or fullscreen mode we need to
@@ skipping 40 matching lines @@
     if (new_bounds.size() == old_bounds.size())
       return;
 
     // If size changed then give the client a chance to produce new contents
     // before origin on screen is changed by adding offset to the next configure
     // request and offset |origin_| by the same distance.
     gfx::Vector2d origin_offset = new_bounds.origin() - old_bounds.origin();
     pending_origin_config_offset_ += origin_offset;
     origin_ -= origin_offset;
 
+    gfx::Rect client_view_bounds =
+        widget_->non_client_view()->frame_view()->GetBoundsForClientView();
+
+    // Update surface bounds.
     surface_->window()->SetBounds(
-        gfx::Rect(GetSurfaceOrigin(), surface_->window()->layer()->size()));
+        gfx::Rect(GetSurfaceOrigin() + client_view_bounds.OffsetFromOrigin(),
+                  surface_->window()->layer()->size()));
 
     // The shadow size may be updated to match the widget. Change it back
     // to the shadow content size.
     // TODO(oshima): When the arc window reiszing is enabled, we may want to
     // implement shadow management here instead of using shadow controller.
     UpdateShadow();
 
     Configure();
   }
 }
@@ skipping 166 matching lines @@
                                 window_state->GetStateType());
   }
 
   // Disable movement if initial bounds were specified.
   widget_->set_movement_disabled(!initial_bounds_.IsEmpty());
   window_state->set_ignore_keyboard_bounds_change(!initial_bounds_.IsEmpty());
 
   // AutoHide shelf in fullscreen state.
   window_state->set_hide_shelf_when_fullscreen(false);
 
-  // Allow Ash to manage the position of a top-level shell surfaces if show
-  // state is one that allows auto positioning and |initial_bounds_| has
-  // not been set.
-  window_state->set_window_position_managed(
-      ash::wm::ToWindowShowState(ash::wm::WINDOW_STATE_TYPE_AUTO_POSITIONED) ==
-          show_state &&
-      initial_bounds_.IsEmpty());
+  // Fade visibility animations for non-activatable windows.
+  if (!activatable_) {
+    wm::SetWindowVisibilityAnimationType(
+        window, wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
+  }
 
   // Register close window accelerators.
   views::FocusManager* focus_manager = widget_->GetFocusManager();
   for (const auto& entry : kCloseWindowAccelerators) {
     focus_manager->RegisterAccelerator(
         ui::Accelerator(entry.keycode, entry.modifiers),
         ui::AcceleratorManager::kNormalPriority, this);
   }
 
-  // Set delegate for handling of fullscreening.
-  window_state->SetDelegate(std::unique_ptr<ash::wm::WindowStateDelegate>(
-      new CustomWindowStateDelegate(widget_)));
-
   // Receive accessibility changes to update shadow underlay.
   WMHelper::GetInstance()->AddAccessibilityObserver(this);
 
   // Show widget next time Commit() is called.
   pending_show_widget_ = true;
 }
 
 void ShellSurface::Configure() {
   DCHECK(widget_);
 
   // Delay configure callback if |scoped_configure_| is set.
   if (scoped_configure_) {
     scoped_configure_->set_needs_configure();
     return;
   }
 
   gfx::Vector2d origin_offset = pending_origin_config_offset_;
   pending_origin_config_offset_ = gfx::Vector2d();
 
+  ash::wm::WindowState* window_state =
+      ash::wm::GetWindowState(widget_->GetNativeWindow());
+
   // If surface is being resized, save the resize direction.
-  int resize_component =
-      resizer_ ? resizer_->details().window_component : HTCAPTION;
+  int resize_component = window_state->is_dragged()
+                             ? window_state->drag_details()->window_component
+                             : HTCAPTION;
 
-  if (configure_callback_.is_null()) {
+  uint32_t serial = 0;
+  if (!configure_callback_.is_null()) {
+    const views::NonClientView* non_client_view = widget_->non_client_view();
+    serial = configure_callback_.Run(
+        non_client_view->frame_view()->GetBoundsForClientView().size(),
+        ash::wm::GetWindowState(widget_->GetNativeWindow())->GetStateType(),
+        IsResizing(), widget_->IsActive());
+  }
+
+  if (!serial) {
     pending_origin_offset_ += origin_offset;
     pending_resize_component_ = resize_component;
     return;
   }
 
-  uint32_t serial = configure_callback_.Run(
-      widget_->GetWindowBoundsInScreen().size(),
-      ash::wm::GetWindowState(widget_->GetNativeWindow())->GetStateType(),
-      IsResizing(), widget_->IsActive());
-
   // Apply origin offset and resize component at the first Commit() after this
   // configure request has been acknowledged.
   pending_configs_.push_back({serial, origin_offset, resize_component});
   LOG_IF(WARNING, pending_configs_.size() > 100)
       << "Number of pending configure acks for shell surface has reached: "
       << pending_configs_.size();
 }
 
 void ShellSurface::AttemptToStartDrag(int component) {
   DCHECK(widget_);
@@ skipping 87 matching lines @@
   resizer_.reset();
 
   // Notify client that resizing state has changed.
   if (was_resizing)
     Configure();
 
   UpdateWidgetBounds();
 }
 
 bool ShellSurface::IsResizing() const {
-  if (!resizer_)
+  ash::wm::WindowState* window_state =
+      ash::wm::GetWindowState(widget_->GetNativeWindow());
+  if (!window_state->is_dragged())
     return false;
 
-  return resizer_->details().bounds_change &
+  return window_state->drag_details()->bounds_change &
          ash::WindowResizer::kBoundsChange_Resizes;
 }
 
 gfx::Rect ShellSurface::GetVisibleBounds() const {
   // Use |geometry_| if set, otherwise use the visual bounds of the surface.
   return geometry_.IsEmpty() ? gfx::Rect(surface_->window()->layer()->size())
                              : geometry_;
 }
 
 gfx::Point ShellSurface::GetSurfaceOrigin() const {
-  gfx::Rect window_bounds = widget_->GetNativeWindow()->bounds();
-
   // If initial bounds were specified then surface origin is always relative
   // to those bounds.
   if (!initial_bounds_.IsEmpty()) {
-    gfx::Point origin = window_bounds.origin();
+    gfx::Point origin = widget_->GetNativeWindow()->bounds().origin();
     wm::ConvertPointToScreen(widget_->GetNativeWindow()->parent(), &origin);
     return initial_bounds_.origin() - origin.OffsetFromOrigin();
   }
 
   gfx::Rect visible_bounds = GetVisibleBounds();
+  gfx::Rect client_bounds =
+      widget_->non_client_view()->frame_view()->GetBoundsForClientView();
   switch (resize_component_) {
     case HTCAPTION:
       return origin_ - visible_bounds.OffsetFromOrigin();
     case HTBOTTOM:
     case HTRIGHT:
     case HTBOTTOMRIGHT:
       return gfx::Point() - visible_bounds.OffsetFromOrigin();
     case HTTOP:
     case HTTOPRIGHT:
-      return gfx::Point(0, window_bounds.height() - visible_bounds.height()) -
+      return gfx::Point(0, client_bounds.height() - visible_bounds.height()) -
              visible_bounds.OffsetFromOrigin();
       break;
     case HTLEFT:
     case HTBOTTOMLEFT:
-      return gfx::Point(window_bounds.width() - visible_bounds.width(), 0) -
+      return gfx::Point(client_bounds.width() - visible_bounds.width(), 0) -
              visible_bounds.OffsetFromOrigin();
     case HTTOPLEFT:
-      return gfx::Point(window_bounds.width() - visible_bounds.width(),
-                        window_bounds.height() - visible_bounds.height()) -
+      return gfx::Point(client_bounds.width() - visible_bounds.width(),
+                        client_bounds.height() - visible_bounds.height()) -
              visible_bounds.OffsetFromOrigin();
     default:
       NOTREACHED();
       return gfx::Point();
   }
 }
 
 void ShellSurface::UpdateWidgetBounds() {
   DCHECK(widget_);
 
   // Return early if the shell is currently managing the bounds of the widget.
   // 1) When a window is either maximized/fullscreen/pinned, and the bounds
   // isn't controlled by a client.
   ash::wm::WindowState* window_state =
       ash::wm::GetWindowState(widget_->GetNativeWindow());
   if (window_state->IsMaximizedOrFullscreenOrPinned() &&
       !window_state->allow_set_bounds_in_maximized()) {
     return;
   }
 
   // 2) When a window is being dragged.
   if (IsResizing())
     return;
 
   // Return early if there is pending configure requests.
   if (!pending_configs_.empty() || scoped_configure_)
     return;
 
   gfx::Rect visible_bounds = GetVisibleBounds();
-  gfx::Rect new_widget_bounds = visible_bounds;
+  gfx::Rect new_widget_bounds =
+      widget_->non_client_view()->GetWindowBoundsForClientBounds(
+          visible_bounds);
 
   // Avoid changing widget origin unless initial bounds were specified and
   // widget origin is always relative to it.
   if (initial_bounds_.IsEmpty()) {
     new_widget_bounds.set_origin(widget_->GetWindowBoundsInScreen().origin());
   } else {
     new_widget_bounds.set_origin(initial_bounds_.origin() +
                                  visible_bounds.OffsetFromOrigin());
   }
 
   // Update widget origin using the surface origin if the current location of
   // surface is being anchored to one side of the widget as a result of a
   // resize operation.
   if (resize_component_ != HTCAPTION) {
     gfx::Point new_widget_origin =
         GetSurfaceOrigin() + visible_bounds.OffsetFromOrigin();
     wm::ConvertPointToScreen(widget_->GetNativeWindow(), &new_widget_origin);
     new_widget_bounds.set_origin(new_widget_origin);
   }
 
   // Set |ignore_window_bounds_changes_| as this change to window bounds
   // should not result in a configure request.
   DCHECK(!ignore_window_bounds_changes_);
   ignore_window_bounds_changes_ = true;
   if (widget_->GetWindowBoundsInScreen() != new_widget_bounds)
     widget_->SetBounds(new_widget_bounds);
   ignore_window_bounds_changes_ = false;
 
+  gfx::Rect client_view_bounds =
+      widget_->non_client_view()->frame_view()->GetBoundsForClientView();
+
   // A change to the widget size requires surface bounds to be re-adjusted.
   surface_->window()->SetBounds(
-      gfx::Rect(GetSurfaceOrigin(), surface_->window()->layer()->size()));
+      gfx::Rect(GetSurfaceOrigin() + client_view_bounds.OffsetFromOrigin(),
+                surface_->window()->layer()->size()));
 }
 
 void ShellSurface::UpdateShadow() {
   if (!widget_)
     return;
   aura::Window* window = widget_->GetNativeWindow();
-  if (shadow_content_bounds_.IsEmpty()) {
+  if (!shadow_enabled_) {
     wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
     if (shadow_underlay_)
       shadow_underlay_->Hide();
   } else {
     wm::SetShadowType(window, wm::SHADOW_TYPE_RECTANGULAR);
 
+    gfx::Rect shadow_content_bounds = shadow_content_bounds_;
+    if (shadow_content_bounds.IsEmpty())
+      shadow_content_bounds = window->bounds();
+
     // TODO(oshima): Adjust the coordinates from client screen to
     // chromeos screen when multi displays are supported.
     gfx::Point origin = window->bounds().origin();
-    gfx::Point shadow_origin = shadow_content_bounds_.origin();
+    gfx::Point shadow_origin = shadow_content_bounds.origin();
     shadow_origin -= origin.OffsetFromOrigin();
-    gfx::Rect shadow_bounds(shadow_origin, shadow_content_bounds_.size());
+    gfx::Rect shadow_bounds(shadow_origin, shadow_content_bounds.size());
 
     // Always create and show the underlay, even in maximized/fullscreen.
     if (!shadow_underlay_) {
       shadow_underlay_ = new aura::Window(nullptr);
       shadow_underlay_event_handler_ =
           base::MakeUnique<ShadowUnderlayEventHandler>();
       shadow_underlay_->SetTargetHandler(shadow_underlay_event_handler_.get());
       DCHECK(shadow_underlay_->owned_by_parent());
       // Ensure the background area inside the shadow is solid black.
       // Clients that provide translucent contents should not be using
       // rectangular shadows as this method requires opaque contents to
       // cast a shadow that represent it correctly.
       shadow_underlay_->Init(ui::LAYER_SOLID_COLOR);
       shadow_underlay_->layer()->SetColor(SK_ColorBLACK);
       DCHECK(shadow_underlay_->layer()->fills_bounds_opaquely());
       window->AddChild(shadow_underlay_);
       window->StackChildAtBottom(shadow_underlay_);
     }
 
     bool underlay_capture_events =
         WMHelper::GetInstance()->IsSpokenFeedbackEnabled() &&
         widget_->IsActive();
 
-    float shadow_underlay_opacity = rectangular_shadow_background_opacity_;
+    float shadow_underlay_opacity = shadow_background_opacity_;
     // Put the black background layer behind the window if
     // 1) the window is in immersive fullscreen or is active with
     //    spoken feedback enabled.
     // 2) the window can control the bounds of the window in fullscreen (
     //    thus the background can be visible).
     // 3) the window has no transform (the transformed background may
     //    not cover the entire background, e.g. overview mode).
     if ((widget_->IsFullscreen() || underlay_capture_events) &&
         ash::wm::GetWindowState(window)->allow_set_bounds_in_maximized() &&
         window->layer()->GetTargetTransform().IsIdentity()) {
       gfx::Point origin;
       origin -= window->bounds().origin().OffsetFromOrigin();
       shadow_bounds.set_origin(origin);
       shadow_bounds.set_size(window->parent()->bounds().size());
       shadow_underlay_opacity = 1.0f;
     }
 
-    shadow_underlay_->SetBounds(shadow_bounds);
+    gfx::Rect shadow_underlay_bounds = shadow_bounds;
+
+    // Constrain the underlay bounds to the client area in case shell surface
+    // frame is enabled.
+    if (frame_enabled_) {
+      shadow_underlay_bounds.Intersect(
+          widget_->non_client_view()->frame_view()->GetBoundsForClientView());
+    }
+
+    shadow_underlay_->SetBounds(shadow_underlay_bounds);
 
     // TODO(oshima): Setting to the same value should be no-op.
     // crbug.com/642223.
     if (shadow_underlay_opacity !=
         shadow_underlay_->layer()->GetTargetOpacity()) {
       shadow_underlay_->layer()->SetOpacity(shadow_underlay_opacity);
     }
 
     shadow_underlay_->Show();
 
     wm::Shadow* shadow = wm::ShadowController::GetShadowForWindow(window);
     // Maximized/Fullscreen window does not create a shadow.
     if (!shadow)
       return;
 
     if (!shadow_overlay_) {
       shadow_overlay_ = new aura::Window(nullptr);
       DCHECK(shadow_overlay_->owned_by_parent());
       shadow_overlay_->set_ignore_events(true);
       shadow_overlay_->Init(ui::LAYER_NOT_DRAWN);
       shadow_overlay_->layer()->Add(shadow->layer());
       window->AddChild(shadow_overlay_);
       shadow_overlay_->Show();
     }
     shadow_overlay_->SetBounds(shadow_bounds);
     shadow->SetContentBounds(gfx::Rect(shadow_bounds.size()));
+    // Surfaces that can't be activated are usually menus and tooltips. Use a
+    // small style shadow for them.
+    if (!activatable_)
+      shadow->SetStyle(wm::Shadow::STYLE_SMALL);
   }
 }
 
 }  // namespace exo