Implement "pinned" mode in ash.

ash/common/wm/workspace/workspace_layout_manager.cc

 // Copyright (c) 2012 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/workspace/workspace_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/wm/always_on_top_controller.h"
@@ skipping 15 matching lines @@
 
 WorkspaceLayoutManager::WorkspaceLayoutManager(
     WmWindow* window,
     std::unique_ptr<wm::WorkspaceLayoutManagerDelegate> delegate)
     : window_(window),
       root_window_(window->GetRootWindow()),
       root_window_controller_(root_window_->GetRootWindowController()),
       shell_(window_->GetShell()),
       delegate_(std::move(delegate)),
       work_area_in_parent_(wm::GetDisplayWorkAreaBounds(window_)),
-      is_fullscreen_(wm::GetWindowForFullscreenMode(window) != nullptr) {
+      is_fullscreen_(wm::GetWindowForFullscreenMode(window) != nullptr),
+      is_pinned_(WmShell::Get()->IsPinned()) {
+  shell_->AddShellObserver(this);
   shell_->AddActivationObserver(this);
   root_window_->AddObserver(this);
   root_window_controller_->AddObserver(this);
   DCHECK(window->GetBoolProperty(
       WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY));
 }
 
 WorkspaceLayoutManager::~WorkspaceLayoutManager() {
   if (root_window_)
     root_window_->RemoveObserver(this);
-  for (WmWindow* window : windows_)
+  for (WmWindow* window : windows_) {
+    wm::WindowState* window_state = window->GetWindowState();
+    window_state->RemoveObserver(this);
     window->RemoveObserver(this);
+  }
   root_window_->GetRootWindowController()->RemoveObserver(this);
   shell_->RemoveActivationObserver(this);
+  shell_->RemoveShellObserver(this);
 }
 
 void WorkspaceLayoutManager::DeleteDelegate() {
   delegate_.reset();
 }
 
 void WorkspaceLayoutManager::SetMaximizeBackdropDelegate(
     std::unique_ptr<WorkspaceLayoutManagerBackdropDelegate> delegate) {
   backdrop_delegate_.reset(delegate.release());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::LayoutManager implementation:
 
 void WorkspaceLayoutManager::OnWindowResized() {}
 
 void WorkspaceLayoutManager::OnWindowAddedToLayout(WmWindow* child) {
   wm::WindowState* window_state = child->GetWindowState();
   wm::WMEvent event(wm::WM_EVENT_ADDED_TO_WORKSPACE);
   window_state->OnWMEvent(&event);
   windows_.insert(child);
   child->AddObserver(this);
   window_state->AddObserver(this);
   UpdateShelfVisibility();
   UpdateFullscreenState();
   if (backdrop_delegate_)
     backdrop_delegate_->OnWindowAddedToLayout(child);
   WindowPositioner::RearrangeVisibleWindowOnShow(child);

[oshima, 2016/06/18 06:36:10]

I think you also need to update here.

[hidehiko, 2016/06/18 08:32:13]

Done.

 }
 
 void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(WmWindow* child) {
   windows_.erase(child);
   child->RemoveObserver(this);
   child->GetWindowState()->RemoveObserver(this);
 
   if (child->GetTargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
 }
@@ skipping 77 matching lines @@
     AdjustAllWindowsBoundsForWorkAreaChange(&event);
   }
   if (backdrop_delegate_)
     backdrop_delegate_->OnDisplayWorkAreaInsetsChanged();
 }
 
 void WorkspaceLayoutManager::OnFullscreenStateChanged(bool is_fullscreen) {
   if (is_fullscreen_ == is_fullscreen)
     return;
 
+  bool was_always_on_top_allowed = !is_fullscreen_ && !is_pinned_;
   is_fullscreen_ = is_fullscreen;
-  WmWindow* fullscreen_window =
-      is_fullscreen ? wm::GetWindowForFullscreenMode(window_) : nullptr;
-  // Changing always on top state may change window's parent. Iterate on a copy
-  // of |windows_| to avoid invalidating an iterator. Since both workspace and
-  // always_on_top containers' layouts are managed by this class all the
-  // appropriate windows will be included in the iteration.
-  WindowSet windows(windows_);
-  for (auto window : windows) {
-    wm::WindowState* window_state = window->GetWindowState();
-    if (is_fullscreen)
-      window_state->DisableAlwaysOnTop(fullscreen_window);
-    else
-      window_state->RestoreAlwaysOnTop();
+  bool is_always_on_top_allowed = !is_fullscreen_ && !is_pinned_;
+  if (is_always_on_top_allowed != was_always_on_top_allowed) {
+    // In this pass, if is_always_on_top_allowed is false, then fullscreen
+    // window should be found. It is because; the situation only happens
+    // when was_always_on_top_allowed is true, so (is_fullscreen, is_pinned)
+    // is changed from (false, false) to (true, false).
+    UpdateAlwaysOnTop(is_always_on_top_allowed
+                          ? nullptr
+                          : wm::GetWindowForFullscreenMode(window_));
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::WindowObserver implementation:
 
 void WorkspaceLayoutManager::OnWindowTreeChanged(
     WmWindow* window,
     const WmWindowObserver::TreeChangeParams& params) {
   if (!params.target->GetWindowState()->IsActive())
@@ skipping 77 matching lines @@
       old_type == wm::WINDOW_STATE_TYPE_FULLSCREEN) {
     UpdateFullscreenState();
   }
 
   UpdateShelfVisibility();
   if (backdrop_delegate_)
     backdrop_delegate_->OnPostWindowStateTypeChange(window_state, old_type);
 }
 
 //////////////////////////////////////////////////////////////////////////////
+// WorkspaceLayoutManager, ShellObserver implementation:
+
+void WorkspaceLayoutManager::OnPinnedStateChanged(WmWindow* pinned_window) {
+  bool is_pinned = pinned_window->GetWindowState()->IsPinned();
+  if (is_pinned_ == is_pinned)
+    return;
+
+  bool was_always_on_top_allowed = !is_fullscreen_ && !is_pinned_;
+  is_pinned_ = is_pinned;
+  bool is_always_on_top_allowed = !is_fullscreen_ && !is_pinned_;
+  if (is_always_on_top_allowed != was_always_on_top_allowed) {
+    UpdateAlwaysOnTop(is_always_on_top_allowed ? nullptr : pinned_window);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, private:
 
 void WorkspaceLayoutManager::AdjustAllWindowsBoundsForWorkAreaChange(
     const wm::WMEvent* event) {
   DCHECK(event->type() == wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED ||
          event->type() == wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED);
 
   work_area_in_parent_ = wm::GetDisplayWorkAreaBounds(window_);
 
   // Don't do any adjustments of the insets while we are in screen locked mode.
@@ skipping 25 matching lines @@
   // technically any container could get a fullscreen window.
   if (!delegate_)
     return;
   bool is_fullscreen = wm::GetWindowForFullscreenMode(window_) != nullptr;
   if (is_fullscreen != is_fullscreen_) {
     delegate_->OnFullscreenStateChanged(is_fullscreen);
     is_fullscreen_ = is_fullscreen;
   }
 }
 
+void WorkspaceLayoutManager::UpdateAlwaysOnTop(WmWindow* window_on_top) {
+  // Changing always on top state may change window's parent. Iterate on a copy
+  // of |windows_| to avoid invalidating an iterator. Since both workspace and
+  // always_on_top containers' layouts are managed by this class all the
+  // appropriate windows will be included in the iteration.
+  WindowSet windows(windows_);
+  for (auto window : windows) {
+    wm::WindowState* window_state = window->GetWindowState();
+    if (window_on_top)
+      window_state->DisableAlwaysOnTop(window_on_top);
+    else
+      window_state->RestoreAlwaysOnTop();
+  }
+}
+
 }  // namespace ash