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..356805a0db76cbf6feb3c82c8cfec4796241c604 100644
--- a/athena/wm/window_list_provider_impl_unittest.cc
+++ b/athena/wm/window_list_provider_impl_unittest.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 
 #include "athena/test/athena_test_base.h"
+#include "athena/wm/public/window_list_provider_observer.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 
@@ -28,6 +29,54 @@ 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);

[oshima, 2014/09/09 18:28:38]

s/""/std::string()/

[Mr4D (OOO till 08-26), 2014/09/10 00:01:58]

Done.

+        break;
+      }
+    }
+  }
+  return output;
+}
+
+class WindowListObserver : public WindowListProviderObserver {
+ public:
+  WindowListObserver(WindowListProvider* provider) : calls_(0),

[oshima, 2014/09/09 18:28:37]

explicit

[Mr4D (OOO till 08-26), 2014/09/10 00:01:58]

Done.

+                                                     provider_(provider) {
+    provider_->AddObserver(this);
+  }
+  virtual ~WindowListObserver() {
+    provider_->RemoveObserver(this);
+  }
+
+  int calls() const { return calls_; }
+
+  // WindowListProviderObserver:
+  virtual void OnActivityStackingChanged() OVERRIDE {
+    calls_++;
+  }
+
+ private:
+  // The number of calls to the observer.
+  int calls_;
+
+  // The associated WindowListProvider which is observed.
+  WindowListProvider* provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowListObserver);
+};
+
+
 }  // namespace
 
 typedef test::AthenaTestBase WindowListProviderImplTest;
@@ -50,14 +99,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 +126,122 @@ 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.
+  container->AddChild(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()));
+  scoped_ptr<WindowListObserver> observer(
+      new WindowListObserver(list_provider.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.
+  container->AddChild(window1.get());
+  container->AddChild(window2.get());
+  container->AddChild(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());
+
+  EXPECT_EQ(0, observer.get()->calls());
+
+  // Move 2 to the front.
+  list_provider->MoveToFront(window2.get());
+  EXPECT_EQ("1 3 2", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+  EXPECT_EQ(1, observer->calls());
+
+  // 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()));
+  EXPECT_EQ(1, observer->calls());
+
+  // Move 1 (from the back) in front of 2.
+  list_provider->StackWindowFrontOf(window1.get(), window3.get());
+  EXPECT_EQ("3 1 2", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+  EXPECT_EQ(2, observer->calls());
+
+  // Move 2 (from the front) in front of 3.
+  list_provider->StackWindowFrontOf(window2.get(), window3.get());
+  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+  EXPECT_EQ(3, observer->calls());
+
+  // Move 1 (from the front) behind 3.
+  list_provider->StackWindowBehindTo(window1.get(), window3.get());
+  EXPECT_EQ("1 3 2", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+  EXPECT_EQ(4, observer->calls());
+
+  // Move 1 (from the back) in front of 2.
+  list_provider->StackWindowFrontOf(window1.get(), window2.get());
+  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+  EXPECT_EQ(5, observer->calls());
+
+  // Test that no change should also report no call.
+  list_provider->StackWindowFrontOf(window1.get(), window2.get());
+  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+  EXPECT_EQ(5, observer->calls());
+  list_provider->StackWindowBehindTo(window2.get(), window1.get());
+  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+                                    list_provider->GetCurrentWindowList()));
+  EXPECT_EQ(5, observer->calls());
+}
+
 }  // namespace athena