Extracts parameters to WindowTreeHostMus into structure

ui/aura/mus/window_tree_client_unittest.cc

 // Copyright 2015 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/mus/window_tree_client.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/capture_synchronizer.h"
 #include "ui/aura/mus/client_surface_embedder.h"
 #include "ui/aura/mus/focus_synchronizer.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
+#include "ui/aura/mus/window_tree_host_mus_init_params.h"
 #include "ui/aura/test/aura_mus_test_base.h"
 #include "ui/aura/test/mus/test_window_tree.h"
 #include "ui/aura/test/mus/window_tree_client_private.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host_observer.h"
 #include "ui/base/class_property.h"
@@ skipping 677 matching lines @@
   gfx::Point last_event_location_;
   uint32_t event_id_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(InputEventBasicTestEventHandler);
 };
 
 }  // namespace
 
 TEST_F(WindowTreeClientClientTest, InputEventBasic) {
   InputEventBasicTestWindowDelegate window_delegate(window_tree());
-  WindowTreeHostMus window_tree_host(window_tree_client_impl(),
-                                     cc::FrameSinkId(1, 1));
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   const gfx::Rect bounds(0, 0, 100, 100);
   window_tree_host.SetBoundsInPixels(bounds);
   window_tree_host.InitHost();
   window_tree_host.Show();
   EXPECT_EQ(bounds, top_level->bounds());
   EXPECT_EQ(bounds, window_tree_host.GetBoundsInPixels());
   Window child(&window_delegate);
   child.Init(ui::LAYER_NOT_DRAWN);
   top_level->AddChild(&child);
@@ skipping 13 matching lines @@
   EXPECT_TRUE(window_tree()->WasEventAcked(event_id));
   EXPECT_EQ(ui::mojom::EventResult::HANDLED,
             window_tree()->GetEventResult(event_id));
   EXPECT_TRUE(window_delegate.got_move());
   EXPECT_FALSE(window_delegate.was_acked());
   EXPECT_EQ(event_location_in_child, window_delegate.last_event_location());
 }
 
 TEST_F(WindowTreeClientClientTest, InputEventPointerEvent) {
   InputEventBasicTestWindowDelegate window_delegate(window_tree());
-  WindowTreeHostMus window_tree_host(window_tree_client_impl(),
-                                     cc::FrameSinkId(1, 1));
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   const gfx::Rect bounds(0, 0, 100, 100);
   window_tree_host.SetBoundsInPixels(bounds);
   window_tree_host.InitHost();
   window_tree_host.Show();
   EXPECT_EQ(bounds, top_level->bounds());
   EXPECT_EQ(bounds, window_tree_host.GetBoundsInPixels());
   Window child(&window_delegate);
   child.Init(ui::LAYER_NOT_DRAWN);
   top_level->AddChild(&child);
@@ skipping 11 matching lines @@
                                            window_tree_host.display_id(),
                                            ui::Event::Clone(pointer_event), 0);
   EXPECT_TRUE(window_tree()->WasEventAcked(event_id));
   EXPECT_EQ(ui::mojom::EventResult::HANDLED,
             window_tree()->GetEventResult(event_id));
   EXPECT_TRUE(window_delegate.got_move());
   EXPECT_EQ(event_location, window_delegate.last_event_location());
 }
 
 TEST_F(WindowTreeClientClientTest, InputEventFindTargetAndConversion) {
-  WindowTreeHostMus window_tree_host(window_tree_client_impl(),
-                                     cc::FrameSinkId(1, 1));
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   const gfx::Rect bounds(0, 0, 100, 100);
   window_tree_host.SetBoundsInPixels(bounds);
   window_tree_host.InitHost();
   window_tree_host.Show();
   EXPECT_EQ(bounds, top_level->bounds());
   EXPECT_EQ(bounds, window_tree_host.GetBoundsInPixels());
   InputEventBasicTestWindowDelegate window_delegate1(window_tree());
   Window child1(&window_delegate1);
   child1.Init(ui::LAYER_NOT_DRAWN);
@@ skipping 46 matching lines @@
       ui::Event::Clone(*ui_event1.get()), 0);
   EXPECT_TRUE(window_tree()->WasEventAcked(event_id));
   EXPECT_EQ(ui::mojom::EventResult::HANDLED,
             window_tree()->GetEventResult(event_id));
   EXPECT_TRUE(window_delegate1.got_move());
   EXPECT_FALSE(window_delegate2.got_move());
   EXPECT_EQ(gfx::Point(50, 60), window_delegate1.last_event_location());
 }
 
 TEST_F(WindowTreeClientClientTest, InputEventCustomWindowTargeter) {
-  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   const gfx::Rect bounds(0, 0, 100, 100);
   window_tree_host.SetBoundsInPixels(bounds);
   window_tree_host.InitHost();
   window_tree_host.Show();
   EXPECT_EQ(bounds, top_level->bounds());
   EXPECT_EQ(bounds, window_tree_host.GetBoundsInPixels());
   InputEventBasicTestWindowDelegate window_delegate1(window_tree());
   Window child1(&window_delegate1);
   child1.Init(ui::LAYER_NOT_DRAWN);
@@ skipping 44 matching lines @@
   EXPECT_TRUE(window_tree()->WasEventAcked(event_id));
   EXPECT_EQ(ui::mojom::EventResult::HANDLED,
             window_tree()->GetEventResult(event_id));
   EXPECT_TRUE(window_delegate1.got_move());
   EXPECT_FALSE(window_delegate2.got_move());
   EXPECT_EQ(gfx::Point(70, 90), window_delegate1.last_event_location());
 }
 
 TEST_F(WindowTreeClientClientTest, InputEventCaptureWindow) {
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      base::MakeUnique<WindowTreeHostMus>(window_tree_client_impl());
+      base::MakeUnique<WindowTreeHostMus>(
+          CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host->window();
   const gfx::Rect bounds(0, 0, 100, 100);
   window_tree_host->SetBoundsInPixels(bounds);
   window_tree_host->InitHost();
   window_tree_host->Show();
   EXPECT_EQ(bounds, top_level->bounds());
   EXPECT_EQ(bounds, window_tree_host->GetBoundsInPixels());
   std::unique_ptr<InputEventBasicTestWindowDelegate> window_delegate1(
       base::MakeUnique<InputEventBasicTestWindowDelegate>(window_tree()));
   std::unique_ptr<Window> child1(
@@ skipping 54 matching lines @@
   EXPECT_FALSE(window_delegate1->got_move());
   EXPECT_TRUE(window_delegate2->got_move());
   EXPECT_EQ(gfx::Point(30, 30), window_delegate2->last_event_location());
   child2.reset();
   child1.reset();
   window_tree_host.reset();
   capture_client.reset();
 }
 
 TEST_F(WindowTreeClientClientTest, InputEventRootWindow) {
-  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   InputEventBasicTestEventHandler root_handler;
   top_level->AddPreTargetHandler(&root_handler);
   const gfx::Rect bounds(0, 0, 100, 100);
   window_tree_host.SetBoundsInPixels(bounds);
   window_tree_host.InitHost();
   window_tree_host.Show();
   EXPECT_EQ(bounds, top_level->bounds());
   EXPECT_EQ(bounds, window_tree_host.GetBoundsInPixels());
   InputEventBasicTestWindowDelegate child_delegate(window_tree());
@@ skipping 236 matching lines @@
   // trigger DCHECKs.
   child.reset();
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::VISIBLE, true));
 }
 
 TEST_F(WindowTreeClientClientTest, NewTopLevelWindow) {
   const size_t initial_root_count =
       window_tree_client_impl()->GetRoots().size();
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      base::MakeUnique<WindowTreeHostMus>(window_tree_client_impl());
+      base::MakeUnique<WindowTreeHostMus>(
+          CreateInitParamsForTopLevel(window_tree_client_impl()));
   window_tree_host->InitHost();
   EXPECT_FALSE(window_tree_host->window()->TargetVisibility());
   aura::Window* top_level = window_tree_host->window();
   EXPECT_NE(server_id(top_level), server_id(root_window()));
   EXPECT_EQ(initial_root_count + 1,
             window_tree_client_impl()->GetRoots().size());
   EXPECT_TRUE(window_tree_client_impl()->GetRoots().count(top_level) > 0u);
 
   // Ack the request to the windowtree to create the new window.
   uint32_t change_id;
@@ skipping 16 matching lines @@
   // ASSERT_EQ(nullptr, top_level->parent());
 
   // Destroy the first root, shouldn't initiate tear down.
   window_tree_host.reset();
   EXPECT_EQ(initial_root_count, window_tree_client_impl()->GetRoots().size());
 }
 
 TEST_F(WindowTreeClientClientTest, NewTopLevelWindowGetsPropertiesFromData) {
   const size_t initial_root_count =
       window_tree_client_impl()->GetRoots().size();
-  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   EXPECT_EQ(initial_root_count + 1,
             window_tree_client_impl()->GetRoots().size());
 
   EXPECT_FALSE(IsWindowHostVisible(top_level));
   EXPECT_FALSE(top_level->TargetVisibility());
 
   window_tree_host.InitHost();
   EXPECT_FALSE(window_tree_host.window()->TargetVisibility());
 
@@ skipping 18 matching lines @@
   EXPECT_TRUE(IsWindowHostVisible(top_level));
   EXPECT_TRUE(top_level->TargetVisibility());
   EXPECT_EQ(display_id, window_tree_host.display_id());
   EXPECT_EQ(gfx::Rect(0, 0, 3, 4), top_level->bounds());
   EXPECT_EQ(gfx::Rect(1, 2, 3, 4), top_level->GetHost()->GetBoundsInPixels());
 }
 
 TEST_F(WindowTreeClientClientTest, NewWindowGetsAllChangesInFlight) {
   RegisterTestProperties(GetPropertyConverter());
 
-  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   EXPECT_FALSE(top_level->TargetVisibility());
 
   window_tree_host.InitHost();
 
   // Make visibility go from false->true->false. Don't ack immediately.
   top_level->Show();
   top_level->Hide();
 
   // Change bounds to 5, 6, 7, 8.
@@ skipping 219 matching lines @@
   EXPECT_EQ(1u, window_tree()->number_of_changes());
   window_tree()->AckAllChangesOfType(WindowTreeChangeType::REORDER, true);
   EXPECT_EQ(0u, window_tree()->number_of_changes());
 }
 
 TEST_F(WindowTreeClientClientTest,
        TopLevelWindowDestroyedBeforeCreateComplete) {
   const size_t initial_root_count =
       window_tree_client_impl()->GetRoots().size();
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      base::MakeUnique<WindowTreeHostMus>(window_tree_client_impl());
+      base::MakeUnique<WindowTreeHostMus>(
+          CreateInitParamsForTopLevel(window_tree_client_impl()));
   window_tree_host->InitHost();
   EXPECT_EQ(initial_root_count + 1,
             window_tree_client_impl()->GetRoots().size());
 
   ui::mojom::WindowDataPtr data = ui::mojom::WindowData::New();
   data->window_id = server_id(window_tree_host->window());
 
   // Destroy the window before the server has a chance to ack the window
   // creation.
   window_tree_host.reset();
@@ skipping 15 matching lines @@
   RegisterTestProperties(GetPropertyConverter());
   const uint8_t property_value = 11;
   std::map<std::string, std::vector<uint8_t>> properties;
   properties[kTestPropertyServerKey1] =
       ConvertToPropertyTransportValue(property_value);
   const char kUnknownPropertyKey[] = "unknown-property";
   using UnknownPropertyType = int32_t;
   const UnknownPropertyType kUnknownPropertyValue = 101;
   properties[kUnknownPropertyKey] =
       mojo::ConvertTo<std::vector<uint8_t>>(kUnknownPropertyValue);
-  std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      base::MakeUnique<WindowTreeHostMus>(window_tree_client_impl(),
-                                          cc::FrameSinkId(1, 1), &properties);
-  window_tree_host->InitHost();
-  window_tree_host->window()->Show();
+  WindowTreeHostMus window_tree_host(CreateInitParamsForTopLevel(
+      window_tree_client_impl(), std::move(properties)));
+  window_tree_host.InitHost();
+  window_tree_host.window()->Show();
   // Verify the property made it to the window.
   EXPECT_EQ(property_value,
-            window_tree_host->window()->GetProperty(kTestPropertyKey1));
+            window_tree_host.window()->GetProperty(kTestPropertyKey1));
 
   // Get the id of the in flight change for creating the new top level window.
   uint32_t change_id;
   ASSERT_TRUE(window_tree()->GetAndRemoveFirstChangeOfType(
       WindowTreeChangeType::NEW_TOP_LEVEL, &change_id));
 
   // Verify the properties were sent to the server.
   base::Optional<std::unordered_map<std::string, std::vector<uint8_t>>>
       transport_properties = window_tree()->GetLastNewWindowProperties();
   ASSERT_TRUE(transport_properties.has_value());
@@ skipping 28 matching lines @@
 
  private:
   bool root_destroyed_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(CloseWindowWindowTreeHostObserver);
 };
 
 }  // namespace
 
 TEST_F(WindowTreeClientClientTest, CloseWindow) {
-  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   window_tree_host.InitHost();
   CloseWindowWindowTreeHostObserver observer;
   window_tree_host.AddObserver(&observer);
   Window* top_level = window_tree_host.window();
 
   // Close a root window should send close request to the observer of its
   // WindowTreeHost.
   EXPECT_FALSE(observer.root_destroyed());
   window_tree_client()->RequestClose(server_id(top_level));
   EXPECT_TRUE(observer.root_destroyed());
@@ skipping 192 matching lines @@
   EXPECT_EQ(1, capture_recorder.capture_changed_count());
   EXPECT_EQ(child2_id, capture_recorder.last_gained_capture_window_id());
   EXPECT_EQ(0, capture_recorder.last_lost_capture_window_id());
   capture_recorder.reset_capture_captured_count();
 }
 
 TEST_F(WindowTreeClientClientTest, TwoWindowTreesRequestCapture) {
   // Creating a WindowTreeHost so we can have two root windows: top_level
   // and root_window().
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      base::MakeUnique<WindowTreeHostMus>(window_tree_client_impl());
+      base::MakeUnique<WindowTreeHostMus>(
+          CreateInitParamsForTopLevel(window_tree_client_impl()));
   window_tree_host->InitHost();
   Window* top_level = window_tree_host->window();
   std::unique_ptr<client::DefaultCaptureClient> capture_client(
       base::MakeUnique<client::DefaultCaptureClient>());
   client::SetCaptureClient(top_level, capture_client.get());
   window_tree_client_impl()->capture_synchronizer()->AttachToCaptureClient(
       capture_client.get());
   EXPECT_NE(server_id(top_level), server_id(root_window()));
 
   // Ack the request to the windowtree to create the new window.
@@ skipping 198 matching lines @@
   // Simulate the server responding with a bounds change. Server should operate
   // in pixels.
   const gfx::Rect server_changed_bounds(gfx::Rect(0, 0, 200, 200));
   window_tree_client()->OnWindowBoundsChanged(
       server_id(root_window()), original_bounds, server_changed_bounds,
       base::nullopt);
   EXPECT_EQ(new_bounds, root_window()->bounds());
 }
 
 TEST_F(WindowTreeClientClientTestHighDPI, NewTopLevelWindowBounds) {
-  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   Window* top_level = window_tree_host.window();
   window_tree_host.InitHost();
 
   ui::mojom::WindowDataPtr data = ui::mojom::WindowData::New();
   data->window_id = server_id(top_level);
   data->bounds.SetRect(2, 4, 6, 8);
   const int64_t display_id = 10;
   uint32_t change_id;
   ASSERT_TRUE(window_tree()->GetAndRemoveFirstChangeOfType(
       WindowTreeChangeType::NEW_TOP_LEVEL, &change_id));
@@ skipping 35 matching lines @@
   // Delegate received the event in Dips.
   const ui::PointerEvent* last_event = last_event_observed();
   ASSERT_TRUE(last_event);
   EXPECT_EQ(gfx::ConvertPointToDIP(2.0f, location_pixels),
             last_event->location());
   EXPECT_EQ(gfx::ConvertPointToDIP(2.0f, root_location_pixels),
             last_event->root_location());
 }
 
 TEST_F(WindowTreeClientClientTestHighDPI, InputEventsInDip) {
-  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  WindowTreeHostMus window_tree_host(
+      CreateInitParamsForTopLevel(window_tree_client_impl()));
   display::Screen* screen = display::Screen::GetScreen();
   display::Display display;
   ASSERT_TRUE(
       screen->GetDisplayWithDisplayId(window_tree_host.display_id(), &display));
   ASSERT_EQ(2.0f, display.device_scale_factor());
 
   Window* top_level = window_tree_host.window();
   const gfx::Rect bounds_in_pixels(0, 0, 100, 100);
   window_tree_host.SetBoundsInPixels(bounds_in_pixels);
   window_tree_host.InitHost();
@@ skipping 52 matching lines @@
             window_tree()->GetEventResult(event_id));
   EXPECT_TRUE(window_delegate1.got_move());
   EXPECT_FALSE(window_delegate2.got_move());
   gfx::Point transformed_event_location_in_dip(event_location_in_dip.x() + 20,
                                                event_location_in_dip.y() + 30);
   EXPECT_EQ(transformed_event_location_in_dip,
             window_delegate1.last_event_location());
 }
 
 }  // namespace aura