exo: Implement version 2 of remote shell interface.

components/exo/shell_surface.h

 // 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.
 
 #ifndef COMPONENTS_EXO_SHELL_SURFACE_H_
 #define COMPONENTS_EXO_SHELL_SURFACE_H_
 
 #include <deque>
 #include <memory>
 #include <string>
@@ skipping 31 matching lines @@
                      public views::WidgetDelegate,
                      public views::View,
                      public ash::wm::WindowStateObserver,
                      public aura::WindowObserver,
                      public aura::client::ActivationChangeObserver {
  public:
   ShellSurface(Surface* surface,
                ShellSurface* parent,
                const gfx::Rect& initial_bounds,
                bool activatable,
-               bool resizeable,
                int container);
   explicit ShellSurface(Surface* surface);
   ~ShellSurface() override;
 
   // Set the callback to run when the user wants the shell surface to be closed.
   // The receiver can chose to not close the window on this signal.
   void set_close_callback(const base::Closure& close_callback) {
     close_callback_ = close_callback;
   }
 
   // Set the callback to run when the surface is destroyed.
   void set_surface_destroyed_callback(
       const base::Closure& surface_destroyed_callback) {
     surface_destroyed_callback_ = surface_destroyed_callback;
   }
 
+  // Set the callback to run when the surface state changed.
+  using StateChangedCallback =
+      base::Callback<void(ash::wm::WindowStateType old_state_type,
+                          ash::wm::WindowStateType new_state_type)>;
+  void set_state_changed_callback(
+      const StateChangedCallback& state_changed_callback) {
+    state_changed_callback_ = state_changed_callback;
+  }
+
   // Set the callback to run when the client is asked to configure the surface.
   // The size is a hint, in the sense that the client is free to ignore it if
   // it doesn't resize, pick a smaller size (to satisfy aspect ratio or resize
   // in steps of NxM pixels).
   using ConfigureCallback =
       base::Callback<uint32_t(const gfx::Size& size,
                               ash::wm::WindowStateType state_type,
                               bool resizing,
                               bool activated)>;
   void set_configure_callback(const ConfigureCallback& configure_callback) {
     configure_callback_ = configure_callback;
   }
 
   // When the client is asked to configure the surface, it should acknowledge
   // the configure request sometime before the commit. |serial| is the serial
   // from the configure callback.
   void AcknowledgeConfigure(uint32_t serial);
 
   // Set the "parent" of this surface. This window should be stacked above a
   // parent.
   void SetParent(ShellSurface* parent);
 
   // Maximizes the shell surface.
   void Maximize();
 
+  // Minimize the shell surface.
+  void Minimize();
+
   // Restore the shell surface.
   void Restore();
 
   // Set fullscreen state for shell surface.
   void SetFullscreen(bool fullscreen);
 
   // Set title for surface.
   void SetTitle(const base::string16& title);
 
   // Sets the application ID for the window. The application ID identifies the
@@ skipping 33 matching lines @@
   std::unique_ptr<base::trace_event::TracedValue> AsTracedValue() const;
 
   // Overridden from SurfaceDelegate:
   void OnSurfaceCommit() override;
   bool IsSurfaceSynchronized() const override;
 
   // Overridden from SurfaceObserver:
   void OnSurfaceDestroying(Surface* surface) override;
 
   // Overridden from views::WidgetDelegate:
+  bool CanResize() const override;
   bool CanMaximize() const override;
-  bool CanResize() const override;
+  bool CanMinimize() const override;
   base::string16 GetWindowTitle() const override;
   void WindowClosing() override;
   views::Widget* GetWidget() override;
   const views::Widget* GetWidget() const override;
   views::View* GetContentsView() override;
   views::NonClientFrameView* CreateNonClientFrameView(
       views::Widget* widget) override;
   bool WidgetHasHitTestMask() const override;
   void GetWidgetHitTestMask(gfx::Path* mask) const override;
 
@@ skipping 55 matching lines @@
   gfx::Point GetSurfaceOrigin() const;
 
   // Updates the bounds of widget to match the current surface bounds.
   void UpdateWidgetBounds();
 
   views::Widget* widget_;
   Surface* surface_;
   aura::Window* parent_;
   const gfx::Rect initial_bounds_;
   const bool activatable_;
-  const bool resizeable_;
   // Container Window Id (see ash/common/shell_window_ids.h)
   const int container_;
+  bool pending_show_widget_;
   base::string16 title_;
   std::string application_id_;
   gfx::Rect geometry_;
   gfx::Rect pending_geometry_;
   double scale_;
   double pending_scale_;
   base::Closure close_callback_;
   base::Closure surface_destroyed_callback_;
+  StateChangedCallback state_changed_callback_;
   ConfigureCallback configure_callback_;
   ScopedConfigure* scoped_configure_;
   bool ignore_window_bounds_changes_;
   gfx::Point origin_;
   gfx::Vector2d pending_origin_offset_;
   gfx::Vector2d pending_origin_config_offset_;
   int resize_component_;  // HT constant (see ui/base/hit_test.h)
   int pending_resize_component_;
   std::deque<Config> pending_configs_;
   std::unique_ptr<ash::WindowResizer> resizer_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellSurface);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_SHELL_SURFACE_H_