Adding functions to the window_list_provider for accessing the activities window list

athena/wm/window_list_provider_impl_unittest.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 "athena/wm/window_list_provider_impl.h"
 
 #include <algorithm>
 
 #include "athena/test/athena_test_base.h"
 #include "ui/aura/test/test_window_delegate.h"
@@ skipping 10 matching lines @@
 }
 
 scoped_ptr<aura::Window> CreateWindow(aura::WindowDelegate* delegate,
                                       ui::wm::WindowType window_type) {
   scoped_ptr<aura::Window> window(new aura::Window(delegate));
   window->SetType(window_type);
   window->Init(aura::WINDOW_LAYER_SOLID_COLOR);
   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;
 
 // Tests that the order of windows match the stacking order of the windows in
 // the container, even after the order is changed through the aura Window API.
 TEST_F(WindowListProviderImplTest, StackingOrder) {
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> container(new aura::Window(&delegate));
   scoped_ptr<aura::Window> first =
       CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
   scoped_ptr<aura::Window> second =
       CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
   scoped_ptr<aura::Window> third =
       CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
   container->AddChild(first.get());
   container->AddChild(second.get());
   container->AddChild(third.get());
 
   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));
   scoped_ptr<aura::Window> first =
       CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
   scoped_ptr<aura::Window> second =
       CreateWindow(&delegate, ui::wm::WINDOW_TYPE_POPUP);
   scoped_ptr<aura::Window> third =
       CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
   scoped_ptr<aura::Window> fourth =
       CreateWindow(&delegate, ui::wm::WINDOW_TYPE_MENU);
   container->AddChild(first.get());
   container->AddChild(second.get());
   container->AddChild(third.get());
   container->AddChild(fourth.get());
 
   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