Revert of Support modal windows

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/screen/public/screen_manager.h"
 #include "athena/test/base/athena_test_base.h"
-#include "athena/test/base/test_windows.h"
 #include "athena/wm/public/window_list_provider_observer.h"
 #include "athena/wm/public/window_manager.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/wm/core/window_util.h"
 
 namespace athena {
 
 namespace {
 
 bool AreWindowListsEqual(const aura::Window::Windows& one,
                          const aura::Window::Windows& two) {
   return one.size() == two.size() &&
          std::equal(one.begin(), one.end(), two.begin());
 }
 
 scoped_ptr<aura::Window> CreateWindow(aura::Window* parent,
                                       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);
   if (parent)
     parent->AddChild(window.get());
   return window.Pass();
 }
 
+scoped_ptr<aura::Window> CreateTransientWindow(aura::Window* transient_parent,
+                                               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);
+  wm::AddTransientChild(transient_parent, window.get());
+  aura::client::ParentWindowWithContext(
+      window.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
+  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) {
@@ skipping 48 matching lines @@
 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<WindowListProvider> list_provider(
       new WindowListProviderImpl(container.get()));
 
-  scoped_ptr<aura::Window> first = test::CreateWindowWithType(
-      &delegate, container.get(), ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> first =
+      CreateWindow(container.get(), &delegate, ui::wm::WINDOW_TYPE_NORMAL);
   scoped_ptr<aura::Window> second =
       CreateWindow(container.get(), &delegate, ui::wm::WINDOW_TYPE_NORMAL);
   scoped_ptr<aura::Window> third =
       CreateWindow(container.get(), &delegate, ui::wm::WINDOW_TYPE_NORMAL);
 
   EXPECT_EQ(3u, container->children().size());
   EXPECT_EQ(container->children().size(),
             list_provider->GetWindowList().size());
 
   EXPECT_TRUE(AreWindowListsEqual(container->children(),
@@ skipping 169 matching lines @@
 // Test that transient windows are handled property.
 TEST_F(WindowListProviderImplTest, TransientWindows) {
   aura::test::TestWindowDelegate delegate;
   delegate.set_can_focus(true);
 
   WindowListProvider* list_provider =
       WindowManager::Get()->GetWindowListProvider();
 
   scoped_ptr<WindowListObserver> observer(
       new WindowListObserver(list_provider));
-  scoped_ptr<aura::Window> w1 = test::CreateNormalWindow(&delegate, NULL);
+  scoped_ptr<aura::Window> w1 = CreateTestWindow(&delegate, gfx::Rect());
   w1->Show();
-  scoped_ptr<aura::Window> w2 = test::CreateNormalWindow(&delegate, NULL);
+  scoped_ptr<aura::Window> w2 = CreateTestWindow(&delegate, gfx::Rect());
   w2->Show();
-  scoped_ptr<aura::Window> t1 = test::CreateTransientWindow(
-      &delegate, w1.get(), ui::MODAL_TYPE_NONE, false);
+  scoped_ptr<aura::Window> t1 =
+      CreateTransientWindow(w1.get(), &delegate, ui::wm::WINDOW_TYPE_NORMAL);
   t1->Show();
 
   EXPECT_EQ(2u, list_provider->GetWindowList().size());
 
   // Activation should honor transient relations.
   wm::ActivateWindow(w2.get());
   EXPECT_EQ(w1.get(), list_provider->GetWindowList()[0]);
   EXPECT_EQ(w2.get(), list_provider->GetWindowList()[1]);
 
   EXPECT_EQ(w1.get(), w1->parent()->children()[0]);
@@ skipping 24 matching lines @@
   EXPECT_FALSE(t1->IsVisible());
   w1->Show();
   EXPECT_TRUE(t1->IsVisible());
 
   // Resetting transient window won't notify the observer.
   t1.reset();
   EXPECT_EQ(0, observer->window_removal_calls());
 }
 
 }  // namespace athena