Adding functions to the window_list_provider for accessing the activities window list

athena/wm/window_list_provider_impl_unittest.cc

Index: athena/wm/window_list_provider_impl_unittest.cc
diff --git a/athena/wm/window_list_provider_impl_unittest.cc b/athena/wm/window_list_provider_impl_unittest.cc
index eba6b7a9ca58fd446860e4ff0261850d429f44ca..dcbf45f2d7f4d7b9c89e59eeb22d2b23cd5accbd 100644
--- a/athena/wm/window_list_provider_impl_unittest.cc
+++ b/athena/wm/window_list_provider_impl_unittest.cc
@@ -28,6 +28,26 @@ scoped_ptr<aura::Window> CreateWindow(aura::WindowDelegate* delegate,
   return window.Pass();
 }
 
+// Return a string which defines the order of windows in |now| using the indices
+// of |original|. The string will then have the lowest/oldest window on the left
+// and the highest / newest on the right.
+std::string GetWindowOrder(const aura::Window::Windows& original,
+                           const aura::Window::Windows& now) {
+  if (original.size() != now.size())
+    return "size has changed.";
+  std::string output;
+  for (aura::Window::Windows::const_iterator it = now.begin();
+       it != now.end(); ++it) {
+    for (size_t i = 0; i < original.size(); i++) {
+      if ((*it) == original[i]) {
+        output += (output.size() ? " " : "") + std::to_string(i + 1);
+        break;
+      }
+    }
+  }
+  return output;
+}
+
 }  // namespace
 
 typedef test::AthenaTestBase WindowListProviderImplTest;
@@ -50,14 +70,15 @@ TEST_F(WindowListProviderImplTest, StackingOrder) {
   scoped_ptr<WindowListProvider> list_provider(
       new WindowListProviderImpl(container.get()));
   EXPECT_TRUE(AreWindowListsEqual(container->children(),
-                                  list_provider->GetWindowList()));
+                                  list_provider->GetCurrentWindowList()));
 
   container->StackChildAtTop(first.get());
   EXPECT_TRUE(AreWindowListsEqual(container->children(),
-                                  list_provider->GetWindowList()));
+                                  list_provider->GetCurrentWindowList()));
   EXPECT_EQ(first.get(), container->children().back());
 }
 
+// Tests that only normal windows of the associated container will be listed.
 TEST_F(WindowListProviderImplTest, ListContainsOnlyNormalWindows) {
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> container(new aura::Window(&delegate));
@@ -76,11 +97,94 @@ TEST_F(WindowListProviderImplTest, ListContainsOnlyNormalWindows) {
 
   scoped_ptr<WindowListProvider> list_provider(
       new WindowListProviderImpl(container.get()));
-  const aura::Window::Windows list = list_provider->GetWindowList();
+
+  const aura::Window::Windows list = list_provider->GetCurrentWindowList();
   EXPECT_EQ(list.end(), std::find(list.begin(), list.end(), second.get()));
   EXPECT_EQ(list.end(), std::find(list.begin(), list.end(), fourth.get()));
   EXPECT_NE(list.end(), std::find(list.begin(), list.end(), first.get()));
   EXPECT_NE(list.end(), std::find(list.begin(), list.end(), third.get()));
 }
 
+// Testing that IsValidWidow, IsWindowInList and AddWindow work as expected.
+TEST_F(WindowListProviderImplTest, SimpleChecks) {
+  aura::test::TestWindowDelegate delegate;
+  scoped_ptr<aura::Window> container(new aura::Window(&delegate));
+
+  scoped_ptr<aura::Window> normal_window =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> popup_window =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_POPUP);
+  scoped_ptr<aura::Window> menu_window =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_MENU);
+
+  scoped_ptr<WindowListProvider> list_provider(
+      new WindowListProviderImpl(container.get()));
+
+  // Check which windows are valid and which are not.
+  EXPECT_TRUE(list_provider->IsValidWindow(normal_window.get()));
+  EXPECT_FALSE(list_provider->IsValidWindow(popup_window.get()));
+  EXPECT_FALSE(list_provider->IsValidWindow(menu_window.get()));
+
+  // Check that no window is currently in the list.
+  EXPECT_FALSE(list_provider->IsWindowInList(normal_window.get()));
+  EXPECT_FALSE(list_provider->IsWindowInList(popup_window.get()));
+  EXPECT_FALSE(list_provider->IsWindowInList(menu_window.get()));
+
+  // Check that adding the window will add it to the list.
+  list_provider->AddWindow(normal_window.get());
+  EXPECT_TRUE(list_provider->IsWindowInList(normal_window.get()));
+}
+
+// Testing that window ordering functions work as expected.
+TEST_F(WindowListProviderImplTest, TestWindowOrderingFunctions) {
+  aura::test::TestWindowDelegate delegate;
+  scoped_ptr<aura::Window> container(new aura::Window(&delegate));
+
+  scoped_ptr<aura::Window> window1 =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> window2 =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> window3 =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+
+  scoped_ptr<WindowListProvider> list_provider(
+      new WindowListProviderImpl(container.get()));
+
+  EXPECT_FALSE(list_provider->IsWindowInList(window1.get()));
+  EXPECT_FALSE(list_provider->IsWindowInList(window2.get()));
+  EXPECT_FALSE(list_provider->IsWindowInList(window3.get()));
+
+  // Add the windows.
+  list_provider->AddWindow(window1.get());
+  list_provider->AddWindow(window2.get());
+  list_provider->AddWindow(window3.get());
+  aura::Window::Windows original_order = list_provider->GetCurrentWindowList();
+  ASSERT_EQ(3U, original_order.size());
+  EXPECT_EQ(original_order[0], window1.get());
+  EXPECT_EQ(original_order[1], window2.get());
+  EXPECT_EQ(original_order[2], window3.get());
+
+  // Move 2 to the front.
+  list_provider->MoveToFront(window2.get());
+  EXPECT_EQ("1 3 2", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+
+  // Move 2 to the front again. Should not change anything.
+  list_provider->MoveToFront(window2.get());
+  EXPECT_EQ("1 3 2", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+
+  // Move 1 (from the back) in front of 2.
+  list_provider->MoveWindowInFrontOfReferenceWindow(window1.get(),
+                                                    window3.get());
+  EXPECT_EQ("3 1 2", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+
+  // Move 2 (from the front) in front of 3.
+  list_provider->MoveWindowInFrontOfReferenceWindow(window2.get(),
+                                                    window3.get());
+  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+}
+
 }  // namespace athena