Add WM_EVENT_TRUSTED_PIN and WINDOW_STATE_TYPE_TRUSTED_PINNED to Ash.

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/shell_window_ids.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"
@@ skipping 187 matching lines @@
     case WM_EVENT_DOCK:
       next_state_type = WINDOW_STATE_TYPE_DOCKED;
       break;
     case WM_EVENT_SET_BOUNDS:
       SetBounds(window_state, static_cast<const SetBoundsEvent*>(event));
       return;
     case WM_EVENT_SHOW_INACTIVE:
       next_state_type = WINDOW_STATE_TYPE_INACTIVE;
       break;
     case WM_EVENT_PIN:
+    case WM_EVENT_TRUSTED_PIN:
       // If there already is a pinned window, it is not allowed to set it
       // to this window.
       // TODO(hidehiko): If a system modal window is openening, the pinning
       // probably should fail.
       if (WmShell::Get()->IsPinned()) {
         LOG(ERROR) << "An PIN event is triggered, while another window is "
                    << "already in pinned mode.";
         next_state_type = current_state_type;
       } else {
-        next_state_type = WINDOW_STATE_TYPE_PINNED;
+        next_state_type = event->type() == WM_EVENT_PIN
+                              ? WINDOW_STATE_TYPE_PINNED
+                              : WINDOW_STATE_TYPE_TRUSTED_PINNED;
       }
       break;
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
     case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
     case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
     case WM_EVENT_CENTER:
@@ skipping 147 matching lines @@
       CycleSnapDock(window_state, event->type());
       return true;
     case WM_EVENT_CENTER:
       CenterWindow(window_state);
       return true;
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_PIN:
+    case WM_EVENT_TRUSTED_PIN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
     case WM_EVENT_DOCK:
       break;
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       NOTREACHED() << "Workspace event should not reach here:" << event;
@@ skipping 91 matching lines @@
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
     case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
     case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
     case WM_EVENT_CENTER:
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_PIN:
+    case WM_EVENT_TRUSTED_PIN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
     case WM_EVENT_DOCK:
       break;
   }
   return false;
 }
 
@@ skipping 73 matching lines @@
     // Normal state should have no restore bounds unless it's
     // unminimized.
     if (!restore_bounds_in_screen.IsEmpty())
       window_state->SetRestoreBoundsInScreen(restore_bounds_in_screen);
     else if (window_state->IsNormalStateType())
       window_state->ClearRestoreBounds();
   }
   window_state->NotifyPostStateTypeChange(previous_state_type);
 
   if (next_state_type == WINDOW_STATE_TYPE_PINNED ||
-      previous_state_type == WINDOW_STATE_TYPE_PINNED) {
+      previous_state_type == WINDOW_STATE_TYPE_PINNED ||
+      next_state_type == WINDOW_STATE_TYPE_TRUSTED_PINNED ||
+      previous_state_type == WINDOW_STATE_TYPE_TRUSTED_PINNED) {
     WmShell::Get()->SetPinnedWindow(window_state->window());
   }
 }
 
 void DefaultState::ReenterToCurrentState(
     WindowState* window_state,
     WindowState::State* state_in_previous_mode) {
   WindowStateType previous_state_type = state_in_previous_mode->GetType();
 
   // A state change should not move a window into or out of full screen or
   // pinned since these are "special mode" the user wanted to be in and
   // should be respected as such.
   if (previous_state_type == wm::WINDOW_STATE_TYPE_FULLSCREEN ||
-      previous_state_type == wm::WINDOW_STATE_TYPE_PINNED) {
+      previous_state_type == wm::WINDOW_STATE_TYPE_PINNED ||
+      previous_state_type == wm::WINDOW_STATE_TYPE_TRUSTED_PINNED) {
     state_type_ = previous_state_type;
   } else if (state_type_ == wm::WINDOW_STATE_TYPE_FULLSCREEN ||
-             state_type_ == wm::WINDOW_STATE_TYPE_PINNED) {
+             state_type_ == wm::WINDOW_STATE_TYPE_PINNED ||
+             state_type_ == wm::WINDOW_STATE_TYPE_TRUSTED_PINNED) {
     state_type_ = previous_state_type;
   }
 
   window_state->UpdateWindowShowStateFromStateType();
   window_state->NotifyPreStateTypeChange(previous_state_type);
 
   if ((state_type_ == wm::WINDOW_STATE_TYPE_NORMAL ||
        state_type_ == wm::WINDOW_STATE_TYPE_DEFAULT) &&
       !stored_bounds_.IsEmpty()) {
     // Use the restore mechanism to set the bounds for
@@ skipping 59 matching lines @@
       wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
                                                       &bounds_in_parent);
       break;
     }
     case WINDOW_STATE_TYPE_MAXIMIZED:
       bounds_in_parent = GetMaximizedWindowBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_FULLSCREEN:
     case WINDOW_STATE_TYPE_PINNED:
+    case WINDOW_STATE_TYPE_TRUSTED_PINNED:
       bounds_in_parent = GetDisplayBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_DOCKED_MINIMIZED:
     case WINDOW_STATE_TYPE_MINIMIZED:
       break;
     case WINDOW_STATE_TYPE_INACTIVE:
     case WINDOW_STATE_TYPE_END:
     case WINDOW_STATE_TYPE_AUTO_POSITIONED:
       return;
@@ skipping 57 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