Add WindowPinType property on arua::Window

ash/common/wm/window_state.cc

 // Copyright 2013 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 "ash/common/wm/window_state.h"
 
 #include <utility>
 
 #include "ash/common/wm/default_state.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state_delegate.h"
 #include "ash/common/wm/window_state_observer.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm_window.h"
+#include "ash/public/cpp/window_properties.h"
 #include "base/auto_reset.h"
 
 namespace ash {
 namespace wm {
 
 namespace {
 
 WMEventType WMEventTypeFromShowState(ui::WindowShowState requested_show_state) {
   switch (requested_show_state) {
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_NORMAL:
       return WM_EVENT_NORMAL;
     case ui::SHOW_STATE_MINIMIZED:
       return WM_EVENT_MINIMIZE;
     case ui::SHOW_STATE_MAXIMIZED:
       return WM_EVENT_MAXIMIZE;
     case ui::SHOW_STATE_FULLSCREEN:
       return WM_EVENT_FULLSCREEN;
     case ui::SHOW_STATE_INACTIVE:
       return WM_EVENT_SHOW_INACTIVE;
 
     case ui::SHOW_STATE_END:
       NOTREACHED() << "No WMEvent defined for the show state:"
                    << requested_show_state;
   }
   return WM_EVENT_NORMAL;
 }
 
+WMEventType WMEventTypeFromWindowPinType(WindowPinType type) {
+  switch (type) {
+    case WindowPinType::NONE:
+      return WM_EVENT_NORMAL;
+    case WindowPinType::PINNED:
+      return WM_EVENT_PIN;
+    case WindowPinType::TRUSTED_PINNED:
+      return WM_EVENT_TRUSTED_PIN;
+  }
+  return WM_EVENT_NORMAL;
+}
+
 }  // namespace
 
 WindowState::~WindowState() {}
 
 bool WindowState::HasDelegate() const {
   return !!delegate_;
 }
 
 void WindowState::SetDelegate(std::unique_ptr<WindowStateDelegate> delegate) {
   DCHECK(!delegate_.get());
@@ skipping 225 matching lines @@
   ClearRestoreBounds();
 }
 
 void WindowState::OnWindowShowStateChanged() {
   if (!ignore_property_change_) {
     WMEvent event(WMEventTypeFromShowState(GetShowState()));
     OnWMEvent(&event);
   }
 }
 
+void WindowState::OnWindowPinTypeChanged() {
+  if (!ignore_property_change_) {
+    WMEvent event(WMEventTypeFromWindowPinType(GetPinType()));
+    OnWMEvent(&event);
+  }
+}
+
 WindowState::WindowState(WmWindow* window)
     : window_(window),
       window_position_managed_(false),
       bounds_changed_by_user_(false),
       ignored_by_shelf_(false),
       can_consume_system_keys_(false),
       unminimize_to_restore_bounds_(false),
       in_immersive_fullscreen_(false),
       hide_shelf_when_fullscreen_(true),
       autohide_shelf_when_maximized_or_fullscreen_(false),
       minimum_visibility_(false),
       can_be_dragged_(true),
       cached_always_on_top_(false),
       ignore_property_change_(false),
       current_state_(new DefaultState(ToWindowStateType(GetShowState()))) {}
 
 bool WindowState::GetAlwaysOnTop() const {
   return window_->IsAlwaysOnTop();
 }
 
 ui::WindowShowState WindowState::GetShowState() const {
   return window_->GetShowState();
 }
 
+WindowPinType WindowState::GetPinType() const {
+  return window_->aura_window()->GetProperty(kWindowPinTypeKey);
+}
+
 void WindowState::SetBoundsInScreen(const gfx::Rect& bounds_in_screen) {
   gfx::Rect bounds_in_parent =
       window_->GetParent()->ConvertRectFromScreen(bounds_in_screen);
   window_->SetBounds(bounds_in_parent);
 }
 
 void WindowState::AdjustSnappedBounds(gfx::Rect* bounds) {
   if (is_dragged() || !IsSnapped())
     return;
   gfx::Rect maximized_bounds = GetMaximizedWindowBoundsInParent(window_);
   if (GetStateType() == WINDOW_STATE_TYPE_LEFT_SNAPPED)
     bounds->set_x(maximized_bounds.x());
   else if (GetStateType() == WINDOW_STATE_TYPE_RIGHT_SNAPPED)
     bounds->set_x(maximized_bounds.right() - bounds->width());
   bounds->set_y(maximized_bounds.y());
   bounds->set_height(maximized_bounds.height());
 }
 
-void WindowState::UpdateWindowShowStateFromStateType() {
+void WindowState::UpdateWindowPropertiesFromStateType() {
   ui::WindowShowState new_window_state =
       ToWindowShowState(current_state_->GetType());
   if (new_window_state != GetShowState()) {
     base::AutoReset<bool> resetter(&ignore_property_change_, true);
     window_->SetShowState(new_window_state);
   }
+
+  // sync up current window show state with PinType property.
+  WindowPinType pin_type = WindowPinType::NONE;
+  if (GetStateType() == WINDOW_STATE_TYPE_PINNED)
+    pin_type = WindowPinType::PINNED;
+  else if (GetStateType() == WINDOW_STATE_TYPE_TRUSTED_PINNED)
+    pin_type = WindowPinType::TRUSTED_PINNED;
+  if (pin_type != GetPinType()) {
+    base::AutoReset<bool> resetter(&ignore_property_change_, true);
+    window_->aura_window()->SetProperty(kWindowPinTypeKey, pin_type);
+  }
 }
 
 void WindowState::NotifyPreStateTypeChange(
     WindowStateType old_window_state_type) {
   for (auto& observer : observer_list_)
     observer.OnPreWindowStateTypeChange(this, old_window_state_type);
 }
 
 void WindowState::NotifyPostStateTypeChange(
     WindowStateType old_window_state_type) {
@@ skipping 36 matching lines @@
   if (!window_->GetTargetVisibility()) {
     SetBoundsConstrained(new_bounds);
     return;
   }
 
   window_->SetBoundsDirectCrossFade(new_bounds);
 }
 
 }  // namespace wm
 }  // namespace ash