exo: Improved implementation of child surfaces and popups.

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/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_state.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/exo/surface.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/path.h"
 #include "ui/views/widget/widget.h"
+#include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(std::string*)
 
 namespace exo {
 namespace {
 
 class CustomFrameView : public views::NonClientFrameView {
  public:
   explicit CustomFrameView(views::Widget* widget) : widget_(widget) {}
@@ skipping 21 matching lines @@
 };
 
 class CustomWindowTargeter : public aura::WindowTargeter {
  public:
   CustomWindowTargeter() {}
   ~CustomWindowTargeter() override {}
 
   // Overridden from aura::WindowTargeter:
   bool EventLocationInsideBounds(aura::Window* window,
                                  const ui::LocatedEvent& event) const override {
-    return PointInsideBounds(window, event.location());
-  }
-
- private:
-  bool PointInsideBounds(const aura::Window* window,
-                         const gfx::Point& point) const {
     Surface* surface = ShellSurface::GetMainSurface(window);
     if (!surface)
       return false;
 
-    gfx::Point local_point = point;
-    if (window->parent()) {
+    gfx::Point local_point = event.location();
+    if (window->parent())
       aura::Window::ConvertPointToTarget(window->parent(), window,
                                          &local_point);
-    }
-
-    // If point is inside a child window then it's also inside the parent.
-    for (const aura::Window* child : window->children()) {
-      if (PointInsideBounds(child, local_point))
-        return true;
-    }
 
     aura::Window::ConvertPointToTarget(window, surface, &local_point);
     return surface->HitTestRect(gfx::Rect(local_point, gfx::Size(1, 1)));
   }
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(CustomWindowTargeter);
 };
 
 class ShellSurfaceWidget : public views::Widget {
  public:
   explicit ShellSurfaceWidget(ShellSurface* shell_surface)
       : shell_surface_(shell_surface) {}
 
   // Overridden from views::Widget
   void Close() override { shell_surface_->Close(); }
 
  private:
   ShellSurface* const shell_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellSurfaceWidget);
 };
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellSurface, public:
 
 DEFINE_LOCAL_WINDOW_PROPERTY_KEY(std::string*, kApplicationIdKey, nullptr)
 DEFINE_LOCAL_WINDOW_PROPERTY_KEY(Surface*, kMainSurfaceKey, nullptr)
 
 ShellSurface::ShellSurface(Surface* surface,
                            ShellSurface* parent,
-                           const gfx::Rect& initial_bounds)
-    : surface_(surface),
+                           const gfx::Rect& initial_bounds,
+                           bool activatable)
+    : widget_(nullptr),
+      surface_(surface),
       parent_(parent ? parent->GetWidget()->GetNativeWindow() : nullptr),
-      initial_bounds_(initial_bounds) {
+      initial_bounds_(initial_bounds),
+      activatable_(activatable) {
   ash::Shell::GetInstance()->activation_client()->AddObserver(this);
   surface_->SetSurfaceDelegate(this);
   surface_->AddSurfaceObserver(this);
   surface_->Show();
   set_owned_by_client();
   if (parent_)
     parent_->AddObserver(this);
 }
 
 ShellSurface::ShellSurface(Surface* surface)
-    : ShellSurface(surface, nullptr, gfx::Rect()) {}
+    : ShellSurface(surface, nullptr, gfx::Rect(), true) {}
 
 ShellSurface::~ShellSurface() {
   ash::Shell::GetInstance()->activation_client()->RemoveObserver(this);
   if (surface_) {
     surface_->SetSurfaceDelegate(nullptr);
     surface_->RemoveSurfaceObserver(this);
   }
   if (parent_)
     parent_->RemoveObserver(this);
   if (widget_) {
     ash::wm::GetWindowState(widget_->GetNativeWindow())->RemoveObserver(this);
     if (widget_->IsVisible())
       widget_->Hide();
     widget_->CloseNow();
   }
 }
 
 void ShellSurface::SetParent(ShellSurface* parent) {
   TRACE_EVENT1("exo", "ShellSurface::SetParent", "parent",
                parent ? base::UTF16ToASCII(parent->title_) : "null");
 
-  if (parent_)
+  if (parent_) {
     parent_->RemoveObserver(this);
+    if (widget_)
+      wm::RemoveTransientChild(parent_, widget_->GetNativeWindow());
+  }
   parent_ = parent ? parent->GetWidget()->GetNativeWindow() : nullptr;
-  if (parent_)
+  if (parent_) {
     parent_->AddObserver(this);
+    if (widget_)
+      wm::AddTransientChild(parent_, widget_->GetNativeWindow());
+  }
 }
 
 void ShellSurface::Maximize() {
   TRACE_EVENT0("exo", "ShellSurface::Maximize");
 
   if (!widget_)
     CreateShellSurfaceWidget();
 
   // Ask client to configure its surface if already maximized.
   if (widget_->IsMaximized()) {
@@ skipping 110 matching lines @@
 // SurfaceDelegate overrides:
 
 void ShellSurface::OnSurfaceCommit() {
   surface_->CommitSurfaceHierarchy();
 
   if (enabled() && !widget_)
     CreateShellSurfaceWidget();
 
   if (widget_) {
     // Update surface bounds and widget size.
-    gfx::Point origin;
-    views::View::ConvertPointToWidget(this, &origin);
-    // Use |geometry_| if set, otherwise use the visual bounds of the surface.
-    gfx::Rect geometry =
-        geometry_.IsEmpty() ? surface_->GetVisibleBounds() : geometry_;
-    surface_->SetBounds(gfx::Rect(origin - geometry.OffsetFromOrigin(),
-                                  surface_->layer()->size()));
-    widget_->SetSize(geometry.size());
+    gfx::Rect visible_bounds = GetVisibleBounds();
+    surface_->SetBounds(
+        gfx::Rect(gfx::Point() - visible_bounds.OffsetFromOrigin(),
+                  surface_->layer()->size()));
+    widget_->SetSize(visible_bounds.size());
 
     // Show widget if not already visible.
     if (!widget_->IsClosed() && !widget_->IsVisible())
       widget_->Show();
   }
 }
 
 bool ShellSurface::IsSurfaceSynchronized() const {
   // A shell surface is always desynchronized.
   return false;
@@ skipping 20 matching lines @@
     surface_destroyed_callback_.Run();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // views::WidgetDelegate overrides:
 
 base::string16 ShellSurface::GetWindowTitle() const {
   return title_;
 }
 
+void ShellSurface::WindowClosing() {
+  SetEnabled(false);
+  widget_ = nullptr;
+}
+
 views::Widget* ShellSurface::GetWidget() {
-  return widget_.get();
+  return widget_;
 }
 
 const views::Widget* ShellSurface::GetWidget() const {
-  return widget_.get();
+  return widget_;
 }
 
 views::View* ShellSurface::GetContentsView() {
   return this;
 }
 
 views::NonClientFrameView* ShellSurface::CreateNonClientFrameView(
     views::Widget* widget) {
   return new CustomFrameView(widget);
 }
@@ skipping 45 matching lines @@
   SetEnabled(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // aura::client::ActivationChangeObserver overrides:
 
 void ShellSurface::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
+  DCHECK(activatable_);
+
   if (!widget_)
     return;
 
   if (gained_active == widget_->GetNativeWindow() ||
       lost_active == widget_->GetNativeWindow()) {
     Configure();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellSurface, private:
 
 void ShellSurface::CreateShellSurfaceWidget() {
   DCHECK(enabled());
   DCHECK(!widget_);
 
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_WINDOW;
-  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.ownership = views::Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET;
   params.delegate = this;
   params.shadow_type = views::Widget::InitParams::SHADOW_TYPE_NONE;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.show_state = ui::SHOW_STATE_NORMAL;
-  gfx::Point position(initial_bounds_.origin());
-  if (parent_) {
-    params.child = true;
-    params.parent = parent_;
-    aura::Window::ConvertPointToTarget(GetMainSurface(parent_), parent_,
-                                       &position);
-  } else {
-    params.parent =
-        ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(),
-                                 ash::kShellWindowId_DefaultContainer);
+  params.parent = ash::Shell::GetContainer(
+      ash::Shell::GetPrimaryRootWindow(), ash::kShellWindowId_DefaultContainer);
+  if (!initial_bounds_.IsEmpty()) {
+    gfx::Point position(initial_bounds_.origin());
+    if (parent_) {
+      aura::Window::ConvertPointToTarget(GetMainSurface(parent_), params.parent,
+                                         &position);
+    }
+    params.bounds = gfx::Rect(position + GetVisibleBounds().OffsetFromOrigin(),
+                              initial_bounds_.size());
   }
-  params.bounds = gfx::Rect(position, initial_bounds_.size());
-  widget_.reset(new ShellSurfaceWidget(this));
+  params.activatable = activatable_ ? views::Widget::InitParams::ACTIVATABLE_YES
+                                    : views::Widget::InitParams::ACTIVATABLE_NO;
+
+  // Note: NativeWidget owns this widget.
+  widget_ = new ShellSurfaceWidget(this);
   widget_->Init(params);
-  widget_->GetNativeWindow()->set_owned_by_parent(false);
   widget_->GetNativeWindow()->SetName("ExoShellSurface");
   widget_->GetNativeWindow()->AddChild(surface_);
   widget_->GetNativeWindow()->SetEventTargeter(
       make_scoped_ptr(new CustomWindowTargeter));
   SetApplicationId(widget_->GetNativeWindow(), &application_id_);
   SetMainSurface(widget_->GetNativeWindow(), surface_);
 
   // Start tracking window state changes.
   ash::wm::GetWindowState(widget_->GetNativeWindow())->AddObserver(this);
 
-  // The position of a top-level shell surface is managed by Ash.
-  ash::wm::GetWindowState(widget_->GetNativeWindow())
-      ->set_window_position_managed(true);
+  // Make shell surface a transient child if |parent_| has been set.
+  if (parent_)
+    wm::AddTransientChild(parent_, widget_->GetNativeWindow());
+
+  // Ash manages the position of a top-level shell surfaces unless
+  // |initial_bounds_| has been set.
+  if (initial_bounds_.IsEmpty()) {
+    ash::wm::GetWindowState(widget_->GetNativeWindow())
+        ->set_window_position_managed(true);
+  }
 }
 
 void ShellSurface::Configure() {
   DCHECK(widget_);
 
   if (configure_callback_.is_null())
     return;
 
   configure_callback_.Run(
       widget_->GetWindowBoundsInScreen().size(),
       ash::wm::GetWindowState(widget_->GetNativeWindow())->GetStateType(),
       widget_->IsActive());
 }
 
+gfx::Rect ShellSurface::GetVisibleBounds() const {
+  // Use |geometry_| if set, otherwise use the visual bounds of the surface.
+  return geometry_.IsEmpty() ? surface_->GetVisibleBounds() : geometry_;
+}
+
 }  // namespace exo