third_party: Update to version 8 of remote_shell_protocol

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 "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 359 matching lines @@
 
 void ShellSurface::SetTitle(const base::string16& title) {
   TRACE_EVENT1("exo", "ShellSurface::SetTitle", "title",
                base::UTF16ToUTF8(title));
 
   title_ = title;
   if (widget_)
     widget_->UpdateWindowTitle();
 }
 
+void ShellSurface::SetSystemModal(bool system_modal) {
+  // System modal container is used by clients to implement client side
+  // managed system modal dialogs using a single ShellSurface instance.
+  // Hit-test region will be non-empty when at least one dialog exists on
+  // the client side. Here we detect the transition between no client side
+  // dialog and at least one dialog so activatable state is properly
+  // updated.
+  if (container_ != ash::kShellWindowId_SystemModalContainer) {
+    LOG(ERROR)
+        << "Only a window in SystemModalContainer can change the modality";
+    return;
+  }
+  widget_->GetNativeWindow()->SetProperty(
+      aura::client::kModalKey,
+      system_modal ? ui::MODAL_TYPE_SYSTEM : ui::MODAL_TYPE_NONE);
+}
+
 // static
 void ShellSurface::SetApplicationId(aura::Window* window,
                                     std::string* application_id) {
   window->SetProperty(kApplicationIdKey, application_id);
 }
 
 // static
 const std::string ShellSurface::GetApplicationId(aura::Window* window) {
   std::string* string_ptr = window->GetProperty(kApplicationIdKey);
   return string_ptr ? *string_ptr : std::string();
@@ skipping 31 matching lines @@
 
   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::SetRectangularRect", "content_bounds",
+  TRACE_EVENT1("exo", "ShellSurface::SetRectangularShadow", "content_bounds",
                content_bounds.ToString());
 
   shadow_content_bounds_ = content_bounds;
 }
 
 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";
@@ skipping 55 matching lines @@
 
     // 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 client side
-    // managed system modal dialogs using a single ShellSurface instance.
-    // Hit-test region will be non-empty when at least one dialog exists on
-    // the client side. Here we detect the transition between no client side
-    // dialog and at least one dialog so activatable state is properly
-    // updated.
+    // 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();
 
       // 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);
-        widget_->GetNativeWindow()->SetProperty(
-            aura::client::kModalKey,
-            activatable ? ui::MODAL_TYPE_SYSTEM : ui::MODAL_TYPE_NONE);
-
         // Activate or deactivate window if activation state changed.
         if (activatable)
           wm::ActivateWindow(widget_->GetNativeWindow());
         else if (widget_->IsActive())
           wm::DeactivateWindow(widget_->GetNativeWindow());
       }
     }
 
     // Update surface bounds.
     surface_->window()->SetBounds(
@@ skipping 585 matching lines @@
 }
 
 void ShellSurface::UpdateShadow() {
   if (!widget_)
     return;
   aura::Window* window = widget_->GetNativeWindow();
   wm::Shadow* shadow = wm::ShadowController::GetShadowForWindow(window);
   if (shadow) {
     if (shadow_content_bounds_.IsEmpty()) {
       wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
+      if (shadow_underlay_)
+        shadow_underlay_->Hide();
     } else {
       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();
       }
       if (!shadow_underlay_) {
         shadow_underlay_ = new aura::Window(nullptr);
         DCHECK(shadow_underlay_->owned_by_parent());
         shadow_underlay_->set_ignore_events(true);
         // 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_);
-        shadow_underlay_->Show();
       }
+      shadow_underlay_->Show();
       gfx::Rect shadow_bounds(shadow_content_bounds_);
       aura::Window::ConvertRectToTarget(window->parent(), window,
                                         &shadow_bounds);
       shadow_overlay_->SetBounds(shadow_bounds);
       shadow_underlay_->SetBounds(shadow_bounds);
       shadow->SetContentBounds(gfx::Rect(shadow_bounds.size()));
       wm::SetShadowType(window, wm::SHADOW_TYPE_RECTANGULAR);
     }
   }
 }
 
 }  // namespace exo