Prevent maximize/minimize/fullscreen-ize window in trusted pinned mode.

ash/common/wm/default_state.cc

 // Copyright 2014 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/default_state.h"
 
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/window_animation_types.h"
 #include "ash/common/wm/window_parenting_utils.h"
 #include "ash/common/wm/window_positioning_utils.h"
@@ skipping 148 matching lines @@
 
 }  // namespace
 
 DefaultState::DefaultState(WindowStateType initial_state_type)
     : state_type_(initial_state_type), stored_window_state_(nullptr) {}
 DefaultState::~DefaultState() {}
 
 void DefaultState::OnWMEvent(WindowState* window_state, const WMEvent* event) {
   if (ProcessWorkspaceEvents(window_state, event))
     return;
 

[oshima, 2016/12/21 01:38:58]

It's probably safer to reject all request in the following condition?

if (current == PINNED && event != UNPIN) {
  return;
}

[hidehiko, 2016/12/21 06:57:30]

Done.

   if (ProcessCompoundEvents(window_state, event))
     return;
 
   WindowStateType current_state_type = window_state->GetStateType();
   WindowStateType next_state_type = WINDOW_STATE_TYPE_NORMAL;
   switch (event->type()) {
     case WM_EVENT_NORMAL:
       next_state_type = current_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED
                             ? WINDOW_STATE_TYPE_DOCKED
                             : WINDOW_STATE_TYPE_NORMAL;
       break;
     case WM_EVENT_MAXIMIZE:
+      if (window_state->IsTrustedPinned())
+        return;
       next_state_type = WINDOW_STATE_TYPE_MAXIMIZED;
       break;
     case WM_EVENT_MINIMIZE:
+      if (window_state->IsTrustedPinned())
+        return;
       next_state_type = current_state_type == WINDOW_STATE_TYPE_DOCKED
                             ? WINDOW_STATE_TYPE_DOCKED_MINIMIZED
                             : WINDOW_STATE_TYPE_MINIMIZED;
       break;
     case WM_EVENT_FULLSCREEN:
+      if (window_state->IsTrustedPinned())
+        return;
       next_state_type = WINDOW_STATE_TYPE_FULLSCREEN;
       break;
     case WM_EVENT_SNAP_LEFT:
       next_state_type = WINDOW_STATE_TYPE_LEFT_SNAPPED;
       break;
     case WM_EVENT_SNAP_RIGHT:
       next_state_type = WINDOW_STATE_TYPE_RIGHT_SNAPPED;
       break;
     case WM_EVENT_DOCK:
       next_state_type = WINDOW_STATE_TYPE_DOCKED;
@@ skipping 86 matching lines @@
   stored_display_state_ = window_state->window()->GetDisplayNearestWindow();
 }
 
 // static
 bool DefaultState::ProcessCompoundEvents(WindowState* window_state,
                                          const WMEvent* event) {
   WmWindow* window = window_state->window();
 
   switch (event->type()) {
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
+      if (window_state->IsTrustedPinned())
+        return true;
       if (window_state->IsFullscreen()) {
         const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
         window_state->OnWMEvent(&event);
       } else if (window_state->IsMaximized()) {
         window_state->Restore();
       } else if (window_state->IsNormalOrSnapped()) {
         if (window_state->CanMaximize())
           window_state->Maximize();
       }
       return true;
     case WM_EVENT_TOGGLE_MAXIMIZE:
+      if (window_state->IsTrustedPinned())
+        return true;
       if (window_state->IsFullscreen()) {
         const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
         window_state->OnWMEvent(&event);
       } else if (window_state->IsMaximized()) {
         window_state->Restore();
       } else if (window_state->CanMaximize()) {
         window_state->Maximize();
       }
       return true;
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE: {
+      if (window_state->IsTrustedPinned())
+        return true;
       gfx::Rect work_area = GetDisplayWorkAreaBoundsInParent(window);
 
       // Maximize vertically if:
       // - The window does not have a max height defined.
       // - The window has the normal state type. Snapped windows are excluded
       //   because they are already maximized vertically and reverting to the
       //   restored bounds looks weird.
       if (window->GetMaximumSize().height() != 0 ||
           !window_state->IsNormalStateType()) {
         return true;
       }
       if (window_state->HasRestoreBounds() &&
           (window->GetBounds().height() == work_area.height() &&
            window->GetBounds().y() == work_area.y())) {
         window_state->SetAndClearRestoreBounds();
       } else {
         window_state->SaveCurrentBoundsForRestore();
         window->SetBounds(gfx::Rect(window->GetBounds().x(), work_area.y(),
                                     window->GetBounds().width(),
                                     work_area.height()));
       }
       return true;
     }
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE: {
+      if (window_state->IsTrustedPinned())
+        return true;
+
       // Maximize horizontally if:
       // - The window does not have a max width defined.
       // - The window is snapped or has the normal state type.
       if (window->GetMaximumSize().width() != 0)
         return true;
       if (!window_state->IsNormalOrSnapped())
         return true;
       gfx::Rect work_area = GetDisplayWorkAreaBoundsInParent(window);
       if (window_state->IsNormalStateType() &&
           window_state->HasRestoreBounds() &&
@@ skipping 13 matching lines @@
           // which match the workspace bounds exactly so it is necessary to set
           // the bounds again below.
         }
 
         window_state->SetRestoreBoundsInParent(restore_bounds);
         window->SetBounds(new_bounds);
       }
       return true;
     }
     case WM_EVENT_TOGGLE_FULLSCREEN:
+      if (window_state->IsTrustedPinned())
+        return true;
       ToggleFullScreen(window_state, window_state->delegate());
       return true;
     case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
     case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
       CycleSnapDock(window_state, event->type());
       return true;
     case WM_EVENT_CENTER:
       CenterWindow(window_state);
       return true;
     case WM_EVENT_NORMAL:
@@ skipping 384 matching lines @@
     gfx::Rect center_in_parent = GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->GetBounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash