Implement "pinned" mode in ash.

ash/wm/pinned_controller_unittest.cc

Index: ash/wm/pinned_controller_unittest.cc
diff --git a/ash/wm/pinned_controller_unittest.cc b/ash/wm/pinned_controller_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..982b935b0c7f24a73bb20dfe87bc3f4c73af4a76
--- /dev/null
+++ b/ash/wm/pinned_controller_unittest.cc
@@ -0,0 +1,163 @@
+// 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/wm/pinned_controller.h"
+
+#include <vector>
+
+#include "ash/aura/wm_window_aura.h"
+#include "ash/common/wm/window_state.h"
+#include "ash/common/wm/wm_event.h"
+#include "ash/common/wm_shell.h"
+#include "ash/common/wm_window.h"
+#include "ash/test/ash_test_base.h"
+#include "ash/wm/window_util.h"
+#include "ui/aura/window.h"
+
+namespace ash {
+namespace test {
+namespace {
+
+int FindIndex(const std::vector<aura::Window*> windows,
+              const aura::Window* target) {

[oshima, 2016/06/17 10:56:51]

you can get index using

auto iter = std::find(...);
return iter - windows.begin();

[hidehiko, 2016/06/17 17:19:22]

Done.

+  for (size_t i = 0; i < windows.size(); ++i) {
+    if (target == windows[i])
+      return static_cast<int>(i);
+  }
+  return -1;
+}
+
+}  // namespace
+
+class PinnedControllerTest : public test::AshTestBase {
+ public:
+  PinnedControllerTest() = default;
+  ~PinnedControllerTest() override = default;
+};
+
+TEST_F(PinnedControllerTest, IsPinned) {
+  aura::Window* w1 = CreateTestWindowInShellWithId(0);
+  wm::ActivateWindow(w1);
+
+  wm::PinWindow(w1);
+  EXPECT_TRUE(WmShell::Get()->IsPinned());
+}
+
+TEST_F(PinnedControllerTest, OnlyOnePinnedWindow) {
+  aura::Window* w1 = CreateTestWindowInShellWithId(0);
+  aura::Window* w2 = CreateTestWindowInShellWithId(1);
+  wm::ActivateWindow(w1);
+
+  wm::PinWindow(w1);
+  EXPECT_TRUE(WmWindowAura::Get(w1)->GetWindowState()->IsPinned());
+  EXPECT_FALSE(WmWindowAura::Get(w2)->GetWindowState()->IsPinned());
+
+  // Prohibit to pin two (or more) windows.
+  wm::PinWindow(w2);
+  EXPECT_TRUE(WmWindowAura::Get(w1)->GetWindowState()->IsPinned());
+  EXPECT_FALSE(WmWindowAura::Get(w2)->GetWindowState()->IsPinned());
+}
+
+TEST_F(PinnedControllerTest, FullscreenInPinnedMode) {
+  aura::Window* w1 = CreateTestWindowInShellWithId(0);
+  aura::Window* w2 = CreateTestWindowInShellWithId(1);
+  wm::ActivateWindow(w1);
+
+  wm::PinWindow(w1);
+  {
+    // Window w1 should be in front of w2.
+    std::vector<aura::Window*> siblings = w1->parent()->children();
+    int index1 = FindIndex(siblings, w1);
+    int index2 = FindIndex(siblings, w2);
+    EXPECT_NE(index1, -1);
+    EXPECT_NE(index2, -1);
+    EXPECT_GT(index1, index2);
+  }
+
+  // Set w2 to fullscreen.
+  {
+    wm::ActivateWindow(w2);
+    const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
+    WmWindowAura::Get(w2)->GetWindowState()->OnWMEvent(&event);
+  }
+  {
+    // Verify that w1 is still in front of w2.
+    std::vector<aura::Window*> siblings = w1->parent()->children();
+    int index1 = FindIndex(siblings, w1);
+    int index2 = FindIndex(siblings, w2);
+    EXPECT_NE(index1, -1);
+    EXPECT_NE(index2, -1);
+    EXPECT_GT(index1, index2);
+  }
+
+  // Unset w2's fullscreen.
+  {
+    wm::ActivateWindow(w2);
+    const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
+    WmWindowAura::Get(w2)->GetWindowState()->OnWMEvent(&event);
+  }
+  {
+    // Verify that w1 is still in front of w2.
+    std::vector<aura::Window*> siblings = w1->parent()->children();
+    int index1 = FindIndex(siblings, w1);
+    int index2 = FindIndex(siblings, w2);
+    EXPECT_NE(index1, -1);
+    EXPECT_NE(index2, -1);
+    EXPECT_GT(index1, index2);
+  }
+
+  // Maximize w2.
+  {
+    wm::ActivateWindow(w2);
+    const wm::WMEvent event(wm::WM_EVENT_TOGGLE_MAXIMIZE);
+    WmWindowAura::Get(w2)->GetWindowState()->OnWMEvent(&event);
+  }
+  {
+    // Verify that w1 is still in front of w2.
+    std::vector<aura::Window*> siblings = w1->parent()->children();
+    int index1 = FindIndex(siblings, w1);
+    int index2 = FindIndex(siblings, w2);
+    EXPECT_NE(index1, -1);
+    EXPECT_NE(index2, -1);
+    EXPECT_GT(index1, index2);
+  }
+
+  // Unset w2's maximize.
+  {
+    wm::ActivateWindow(w2);
+    const wm::WMEvent event(wm::WM_EVENT_TOGGLE_MAXIMIZE);
+    WmWindowAura::Get(w2)->GetWindowState()->OnWMEvent(&event);
+  }
+  {
+    // Verify that w1 is still in front of w2.
+    std::vector<aura::Window*> siblings = w1->parent()->children();
+    int index1 = FindIndex(siblings, w1);
+    int index2 = FindIndex(siblings, w2);
+    EXPECT_NE(index1, -1);
+    EXPECT_NE(index2, -1);
+    EXPECT_GT(index1, index2);
+  }
+
+  // Restore w1.
+  WmWindowAura::Get(w1)->GetWindowState()->Restore();
+
+  // Now, fullscreen-ize w2 should put it in front of w1.
+  {
+    wm::ActivateWindow(w2);
+    const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
+    WmWindowAura::Get(w2)->GetWindowState()->OnWMEvent(&event);
+  }
+  {
+    // Verify that w1 is still in front of w2.
+    std::vector<aura::Window*> siblings = w1->parent()->children();
+    int index1 = FindIndex(siblings, w1);
+    int index2 = FindIndex(siblings, w2);
+    EXPECT_NE(index1, -1);
+    EXPECT_NE(index2, -1);
+    EXPECT_GT(index2, index1);
+  }
+}
+
+}  // namespace test
+}  // namespace ash