Makes WindowTreeHost::InitHost() not Show the window

ui/aura/window_event_dispatcher_unittest.cc

 // Copyright (c) 2012 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 "ui/aura/window_event_dispatcher.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 1605 matching lines @@
             EventTypesToString(w1_filter.events()));
 }
 
 // Tests the case where the event dispatcher is deleted during the pre-dispatch
 // phase of dispatching and event.
 TEST_P(WindowEventDispatcherTest, DeleteDispatcherDuringPreDispatch) {
   // Create a host for the window hierarchy. This host will be destroyed later
   // on.
   WindowTreeHost* host = WindowTreeHost::Create(gfx::Rect(0, 0, 100, 100));
   host->InitHost();
+  host->window()->Show();
 
   // Create two windows.
   Window* w1 = CreateNormalWindow(1, host->window(), nullptr);
   w1->SetBounds(gfx::Rect(20, 20, 60, 60));
   Window* w2 = CreateNormalWindow(2, host->window(), nullptr);
   w2->SetBounds(gfx::Rect(80, 20, 120, 60));
   EXPECT_EQ(nullptr, host->dispatcher()->mouse_moved_handler());
 
   ui::test::EventGenerator generator(host->window(), w1);
 
@@ skipping 57 matching lines @@
 // Verifies GetRootWindow() from ~Window returns a valid root.
 TEST_P(WindowEventDispatcherTest, ValidRootDuringDestruction) {
   bool got_destroying = false;
   bool has_valid_root = false;
   ValidRootDuringDestructionWindowObserver observer(&got_destroying,
                                                     &has_valid_root);
   {
     std::unique_ptr<WindowTreeHost> host(
         WindowTreeHost::Create(gfx::Rect(0, 0, 100, 100)));
     host->InitHost();
+    host->window()->Show();
     // Owned by WindowEventDispatcher.
     Window* w1 = CreateNormalWindow(1, host->window(), NULL);
     w1->AddObserver(&observer);
   }
   EXPECT_TRUE(got_destroying);
   EXPECT_TRUE(has_valid_root);
 }
 
 namespace {
 
@@ skipping 86 matching lines @@
 };
 
 }  // namespace
 
 // Verifies if a WindowTreeHost is deleted from dispatching a held mouse event
 // we don't crash.
 TEST_P(WindowEventDispatcherTest, DeleteHostFromHeldMouseEvent) {
   // Should be deleted by |delegate|.
   WindowTreeHost* h2 = WindowTreeHost::Create(gfx::Rect(0, 0, 100, 100));
   h2->InitHost();
+  h2->window()->Show();
   DeleteHostFromHeldMouseEventDelegate delegate(h2);
   // Owned by |h2|.
   Window* w1 = CreateNormalWindow(1, h2->window(), &delegate);
   w1->SetBounds(gfx::Rect(0, 0, 40, 40));
   ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
                          gfx::Point(10, 10), ui::EventTimeForNow(),
                          ui::EF_SHIFT_DOWN, 0);
   h2->dispatcher()->RepostEvent(&pressed);
   // RunAllPendingInMessageLoop() to make sure the |pressed| is run.
   RunAllPendingInMessageLoop();
@@ skipping 571 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MoveWindowHandler);
 };
 
 // Tests that nested event dispatch works correctly if the target of the older
 // event being dispatched is moved to a different dispatcher in response to an
 // event in the inner loop.
 TEST_P(WindowEventDispatcherTest, NestedEventDispatchTargetMoved) {
   std::unique_ptr<WindowTreeHost> second_host(
       WindowTreeHost::Create(gfx::Rect(20, 30, 100, 50)));
   second_host->InitHost();
+  second_host->window()->Show();
   Window* second_root = second_host->window();
 
   // Create two windows parented to |root_window()|.
   test::TestWindowDelegate delegate;
   std::unique_ptr<Window> first(CreateTestWindowWithDelegate(
       &delegate, 123, gfx::Rect(20, 10, 10, 20), root_window()));
   std::unique_ptr<Window> second(CreateTestWindowWithDelegate(
       &delegate, 234, gfx::Rect(40, 10, 50, 20), root_window()));
 
   // Setup a handler on |first| so that it dispatches an event to |second| when
@@ skipping 42 matching lines @@
 TEST_P(WindowEventDispatcherTest,
        CursorVisibilityChangedWhileCaptureWindowInAnotherDispatcher) {
   test::EventCountDelegate delegate;
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 123, gfx::Rect(20, 10, 10, 20), root_window()));
   window->Show();
 
   std::unique_ptr<WindowTreeHost> second_host(
       WindowTreeHost::Create(gfx::Rect(20, 30, 100, 50)));
   second_host->InitHost();
+  second_host->window()->Show();
   WindowEventDispatcher* second_dispatcher = second_host->dispatcher();
 
   // Install an InputStateLookup on the Env that always claims that a
   // mouse-button is down.
   test::EnvTestHelper(Env::GetInstance())
       .SetInputStateLookup(std::unique_ptr<InputStateLookup>(
           new AlwaysMouseDownInputStateLookup()));
 
   window->SetCapture();
 
@@ skipping 20 matching lines @@
   host()->OnCursorVisibilityChanged(false);
   second_host->OnCursorVisibilityChanged(false);
   EXPECT_EQ("0 0 1", delegate.GetMouseMotionCountsAndReset());
 }
 
 TEST_P(WindowEventDispatcherTest,
        RedirectedEventToDifferentDispatcherLocation) {
   std::unique_ptr<WindowTreeHost> second_host(
       WindowTreeHost::Create(gfx::Rect(20, 30, 100, 50)));
   second_host->InitHost();
+  second_host->window()->Show();
   client::SetCaptureClient(second_host->window(),
                            client::GetCaptureClient(root_window()));
 
   test::EventCountDelegate delegate;
   std::unique_ptr<Window> window_first(CreateTestWindowWithDelegate(
       &delegate, 123, gfx::Rect(20, 10, 10, 20), root_window()));
   window_first->Show();
 
   std::unique_ptr<Window> window_second(CreateTestWindowWithDelegate(
       &delegate, 12, gfx::Rect(10, 10, 20, 30), second_host->window()));
@@ skipping 166 matching lines @@
                         WindowEventDispatcherTestWithMessageLoop,
                         ::testing::Values(test::BackendType::CLASSIC,
                                           test::BackendType::MUS));
 
 INSTANTIATE_TEST_CASE_P(/* no prefix */,
                         WindowEventDispatcherTestInHighDPI,
                         ::testing::Values(test::BackendType::CLASSIC,
                                           test::BackendType::MUS));
 
 }  // namespace aura