exo: Implement version 2 of remote shell interface.

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 143 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // 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,
                            bool activatable,
-                           bool resizeable,
                            int container)
     : widget_(nullptr),
       surface_(surface),
       parent_(parent ? parent->GetWidget()->GetNativeWindow() : nullptr),
       initial_bounds_(initial_bounds),
       activatable_(activatable),
-      resizeable_(resizeable),
       container_(container),
+      pending_show_widget_(false),
       scale_(1.0),
       pending_scale_(1.0),
       scoped_configure_(nullptr),
       ignore_window_bounds_changes_(false),
       resize_component_(HTCAPTION),
       pending_resize_component_(HTCAPTION) {
   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(),
                    true,
-                   true,
                    ash::kShellWindowId_DefaultContainer) {}
 
 ShellSurface::~ShellSurface() {
   DCHECK(!scoped_configure_);
   ash::Shell::GetInstance()->activation_client()->RemoveObserver(this);
   if (surface_) {
     if (scale_ != 1.0)
       surface_->SetTransform(gfx::Transform());
     surface_->SetSurfaceDelegate(nullptr);
     surface_->RemoveSurfaceObserver(this);
@@ skipping 59 matching lines @@
 
   if (!widget_)
     CreateShellSurfaceWidget(ui::SHOW_STATE_MAXIMIZED);
 
   // Note: This will ask client to configure its surface even if already
   // maximized.
   ScopedConfigure scoped_configure(this, true);
   widget_->Maximize();
 }
 
+void ShellSurface::Minimize() {
+  TRACE_EVENT0("exo", "ShellSurface::Minimize");
+
+  if (!widget_)
+    return;
+
+  // Note: This will ask client to configure its surface even if already
+  // minimized.
+  ScopedConfigure scoped_configure(this, true);
+  widget_->Minimize();
+}
+
 void ShellSurface::Restore() {
   TRACE_EVENT0("exo", "ShellSurface::Restore");
 
   if (!widget_)
     return;
 
   // Note: This will ask client to configure its surface even if not already
-  // maximized.
+  // maximized or minimized.
   ScopedConfigure scoped_configure(this, true);
   widget_->Restore();
 }
 
 void ShellSurface::SetFullscreen(bool fullscreen) {
   TRACE_EVENT1("exo", "ShellSurface::SetFullscreen", "fullscreen", fullscreen);
 
   if (!widget_)
     CreateShellSurfaceWidget(ui::SHOW_STATE_FULLSCREEN);
 
@@ skipping 27 matching lines @@
 void ShellSurface::SetApplicationId(const std::string& application_id) {
   TRACE_EVENT1("exo", "ShellSurface::SetApplicationId", "application_id",
                application_id);
 
   application_id_ = application_id;
 }
 
 void ShellSurface::Move() {
   TRACE_EVENT0("exo", "ShellSurface::Move");
 
-  if (widget_)
+  if (widget_ && !widget_->movement_disabled())
     AttemptToStartDrag(HTCAPTION);
 }
 
 void ShellSurface::Resize(int component) {
   TRACE_EVENT1("exo", "ShellSurface::Resize", "component", component);
 
-  if (widget_)
+  if (widget_ && !widget_->movement_disabled())
     AttemptToStartDrag(component);
 }
 
 void ShellSurface::Close() {
   if (!close_callback_.is_null())
     close_callback_.Run();
 }
 
 void ShellSurface::SetGeometry(const gfx::Rect& geometry) {
   TRACE_EVENT1("exo", "ShellSurface::SetGeometry", "geometry",
@@ skipping 90 matching lines @@
 
     // 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_->SetTransform(transform);
       scale_ = pending_scale_;
     }
 
-    // Show widget if not already visible.
-    if (!widget_->IsClosed() && !widget_->IsVisible())
+    // Show widget if needed.
+    if (pending_show_widget_) {
+      DCHECK(!widget_->IsClosed());
+      DCHECK(!widget_->IsVisible());
+      pending_show_widget_ = false;
       widget_->Show();
+    }
   }
 }
 
 bool ShellSurface::IsSurfaceSynchronized() const {
   // A shell surface is always desynchronized.
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceObserver overrides:
@@ skipping 14 matching lines @@
   // Note: In its use in the Wayland server implementation, the surface
   // destroyed callback may destroy the ShellSurface instance. This call needs
   // to be last so that the instance can be destroyed.
   if (!surface_destroyed_callback_.is_null())
     surface_destroyed_callback_.Run();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // views::WidgetDelegate overrides:
 
-bool ShellSurface::CanMaximize() const {
-  return resizeable_;
+bool ShellSurface::CanResize() const {
+  return initial_bounds_.IsEmpty();
 }
 
-bool ShellSurface::CanResize() const {
-  return resizeable_;
+bool ShellSurface::CanMaximize() const {
+  return true;
+}
+
+bool ShellSurface::CanMinimize() const {
+  return true;
 }
 
 base::string16 ShellSurface::GetWindowTitle() const {
   return title_;
 }
 
 void ShellSurface::WindowClosing() {
   if (resizer_)
     EndDrag(true /* revert */);
   SetEnabled(false);
@@ skipping 47 matching lines @@
   ash::wm::WindowStateType new_type = window_state->GetStateType();
   if (old_type == ash::wm::WINDOW_STATE_TYPE_MAXIMIZED ||
       new_type == ash::wm::WINDOW_STATE_TYPE_MAXIMIZED ||
       old_type == ash::wm::WINDOW_STATE_TYPE_FULLSCREEN ||
       new_type == ash::wm::WINDOW_STATE_TYPE_FULLSCREEN) {
     Configure();
   }
 
   if (widget_)
     UpdateWidgetBounds();
+
+  if (!state_changed_callback_.is_null())
+    state_changed_callback_.Run(old_type, new_type);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
 void ShellSurface::OnWindowBoundsChanged(aura::Window* window,
                                          const gfx::Rect& old_bounds,
                                          const gfx::Rect& new_bounds) {
   if (!widget_ || !surface_ || ignore_window_bounds_changes_)
     return;
@@ skipping 117 matching lines @@
 
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_WINDOW;
   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 = show_state;
   params.parent =
       ash::Shell::GetContainer(ash::Shell::GetPrimaryRootWindow(), container_);
-  if (!initial_bounds_.IsEmpty()) {
-    params.bounds = initial_bounds_;
-    if (parent_) {
-      aura::Window::ConvertRectToTarget(GetMainSurface(parent_), params.parent,
-                                        &params.bounds);
-    }
-  }
+  params.bounds = initial_bounds_;
   bool activatable = activatable_ && !surface_->GetHitTestBounds().IsEmpty();
   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);
 
+  // Disable movement if initial bounds were specified.
+  widget_->set_movement_disabled(!initial_bounds_.IsEmpty());
+
   aura::Window* window = widget_->GetNativeWindow();
   window->SetName("ExoShellSurface");
   window->AddChild(surface_);
   window->SetEventTargeter(base::WrapUnique(new CustomWindowTargeter));
   SetApplicationId(window, &application_id_);
   SetMainSurface(window, surface_);
 
   // Start tracking changes to window bounds and window state.
   window->AddObserver(this);
   ash::wm::GetWindowState(window)->AddObserver(this);
 
   // Make shell surface a transient child if |parent_| has been set.
   if (parent_)
     wm::AddTransientChild(parent_, window);
 
   // 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.
   ash::wm::GetWindowState(window)->set_window_position_managed(
       ash::wm::ToWindowShowState(ash::wm::WINDOW_STATE_TYPE_AUTO_POSITIONED) ==
           show_state &&
       initial_bounds_.IsEmpty());
+
+  // 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;
   }
@@ skipping 130 matching lines @@
          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_->layer()->size()) : geometry_;
 }
 
 gfx::Point ShellSurface::GetSurfaceOrigin() const {
   gfx::Rect window_bounds = widget_->GetWindowBoundsInScreen();
+
+  // If initial bounds were specified then surface origin is always relative
+  // to those bounds.
+  if (!initial_bounds_.IsEmpty())
+    return initial_bounds_.origin() - window_bounds.OffsetFromOrigin();
+
   gfx::Rect visible_bounds = GetVisibleBounds();
-
   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()) -
@@ skipping 45 matching lines @@
   DCHECK(!ignore_window_bounds_changes_);
   ignore_window_bounds_changes_ = true;
   widget_->SetBounds(new_widget_bounds);
   ignore_window_bounds_changes_ = false;
 
   // A change to the widget size requires surface bounds to be re-adjusted.
   surface_->SetBounds(gfx::Rect(GetSurfaceOrigin(), surface_->layer()->size()));
 }
 
 }  // namespace exo