exo: Add initial support for service side decorations.

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 33 matching lines @@
                      public views::View,
                      public ash::wm::WindowStateObserver,
                      public aura::WindowObserver,
                      public WMHelper::ActivationObserver,
                      public WMHelper::AccessibilityObserver {
  public:
   ShellSurface(Surface* surface,
                ShellSurface* parent,
                const gfx::Rect& initial_bounds,
                bool activatable,
+               bool can_minimize,
                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;
   }
 
@@ skipping 75 matching lines @@
   void Resize(int component);
 
   // Signal a request to close the window. It is up to the implementation to
   // actually decide to do so though.
   void Close();
 
   // Set geometry for surface. The geometry represents the "visible bounds"
   // for the surface from the user's perspective.
   void SetGeometry(const gfx::Rect& geometry);
 
-  // Set the content bounds for the shadow. Empty bounds will delete
-  // the shadow.
-  void SetRectangularShadow(const gfx::Rect& content_bounds);
+  // Enable/disable rectangular shadow.
+  void SetRectangularShadow(bool enabled);
+
+  // Set the content bounds for the shadow. Shell surface geometry will be
+  // used if bounds are empty.
+  void SetRectangularShadowContentBounds(const gfx::Rect& content_bounds);
 
   // Set the pacity of the background for the window that has a shadow.
   void SetRectangularShadowBackgroundOpacity(float opacity);
 
+  // Enable/disable window frame.
+  void SetFrame(bool enabled);
+
   // Set scale factor for surface. The scale factor will be applied to surface
   // and all descendants.
   void SetScale(double scale);
 
   // Set top inset for surface.
   void SetTopInset(int height);
 
   // Set origin in screen coordinate space.
   void SetOrigin(const gfx::Point& origin);
 
-  // Set activatable state for surface.
-  void SetActivatable(bool activatable);
+  // Set container for surface.
+  void SetContainer(int container);
 
   // Sets the main surface for the window.
   static void SetMainSurface(aura::Window* window, Surface* surface);
 
   // Returns the main Surface instance or nullptr if it is not set.
   // |window| must not be nullptr.
   static Surface* GetMainSurface(const aura::Window* window);
 
   // Returns a trace value representing the state of the surface.
   std::unique_ptr<base::trace_event::TracedValue> AsTracedValue() const;
@@ skipping 14 matching lines @@
   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;
 
   // Overridden from views::View:
   gfx::Size GetPreferredSize() const override;
+  gfx::Size GetMinimumSize() const override;
 
   // Overridden from ash::wm::WindowStateObserver:
   void OnPreWindowStateTypeChange(ash::wm::WindowState* window_state,
                                   ash::wm::WindowStateType old_type) override;
   void OnPostWindowStateTypeChange(ash::wm::WindowState* window_state,
                                    ash::wm::WindowStateType old_type) override;
 
   // Overridden from aura::WindowObserver:
   void OnWindowBoundsChanged(aura::Window* window,
                              const gfx::Rect& old_bounds,
@@ skipping 57 matching lines @@
 
   // Creates, deletes and update the shadow bounds based on
   // |pending_shadow_content_bounds_|.
   void UpdateShadow();
 
   views::Widget* widget_ = nullptr;
   Surface* surface_;
   aura::Window* parent_;
   gfx::Rect initial_bounds_;
   bool activatable_ = true;
+  const bool can_minimize_;
   // Container Window Id (see ash/public/cpp/shell_window_ids.h)
-  const int container_;
+  int container_;
+  bool frame_enabled_ = false;
+  bool shadow_enabled_ = false;
   bool pending_show_widget_ = false;
   base::string16 title_;
   std::string application_id_;
   gfx::Rect geometry_;
   gfx::Rect pending_geometry_;
   double scale_ = 1.0;
   double pending_scale_ = 1.0;
   base::Closure close_callback_;
   base::Closure surface_destroyed_callback_;
   StateChangedCallback state_changed_callback_;
   ConfigureCallback configure_callback_;
   ScopedConfigure* scoped_configure_ = nullptr;
   bool ignore_window_bounds_changes_ = false;
   gfx::Point origin_;
   gfx::Vector2d pending_origin_offset_;
   gfx::Vector2d pending_origin_config_offset_;
   int resize_component_ = HTCAPTION;  // HT constant (see ui/base/hit_test.h)
   int pending_resize_component_ = HTCAPTION;
   aura::Window* shadow_overlay_ = nullptr;
   aura::Window* shadow_underlay_ = nullptr;
   std::unique_ptr<ui::EventHandler> shadow_underlay_event_handler_;
   gfx::Rect shadow_content_bounds_;
+  float shadow_background_opacity_ = 1.0;
   std::deque<Config> pending_configs_;
   std::unique_ptr<ash::WindowResizer> resizer_;
   std::unique_ptr<ScopedAnimationsDisabled> scoped_animations_disabled_;
   int top_inset_height_ = 0;
   int pending_top_inset_height_ = 0;
-  float rectangular_shadow_background_opacity_ = 1.0;
 
   DISALLOW_COPY_AND_ASSIGN(ShellSurface);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_SHELL_SURFACE_H_