Fixes to WindowTreeHostMus

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/logging.h"
 #include "base/macros.h"
 #include "mojo/common/common_type_converters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.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/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_tracker.h"
+#include "ui/compositor/compositor.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(uint8_t)
 
 namespace aura {
 
 namespace {
 
 DEFINE_WINDOW_PROPERTY_KEY(uint8_t, kTestPropertyKey1, 0);
 DEFINE_WINDOW_PROPERTY_KEY(uint8_t, kTestPropertyKey2, 0);
 
 Id server_id(Window* window) {
   return WindowMus::Get(window)->server_id();
 }
 
 void SetWindowVisibility(Window* window, bool visible) {
   if (visible)
     window->Show();
   else
     window->Hide();
 }
 
 Window* GetFirstRoot(WindowTreeClient* client) {
   return client->GetRoots().empty() ? nullptr : *client->GetRoots().begin();
 }
 
+bool IsWindowHostVisible(Window* window) {
+  return window->GetRootWindow()->GetHost()->compositor()->IsVisible();
+}
+
 const char kAlwaysOnTopServerKey[] = "always-on-top-server";
 const char kTestPropertyServerKey1[] = "test-property-server1";
 const char kTestPropertyServerKey2[] = "test-property-server2";
 
 class TestPropertyConverter : public PropertyConverter {
  public:
   TestPropertyConverter() {}
   ~TestPropertyConverter() override {}
 
   // PropertyConverter:
@@ skipping 362 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InputEventBasicTestWindowDelegate);
 };
 
 }  // namespace
 
 TEST_F(WindowTreeClientClientTest, InputEventBasic) {
   InputEventBasicTestWindowDelegate window_delegate(window_tree());
   std::unique_ptr<Window> top_level(base::MakeUnique<Window>(&window_delegate));
   top_level->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   top_level->Init(ui::LAYER_NOT_DRAWN);
-  top_level->SetBounds(gfx::Rect(0, 0, 100, 100));
-  top_level->Show();
+  WindowTreeHost* window_tree_host = top_level->GetRootWindow()->GetHost();
+  const gfx::Rect bounds(0, 0, 100, 100);
+  window_tree_host->SetBounds(bounds);
+  window_tree_host->Show();
+  EXPECT_EQ(bounds, top_level->bounds());
+  EXPECT_EQ(bounds, window_tree_host->window()->bounds());
   EXPECT_FALSE(window_delegate.got_move());
   EXPECT_FALSE(window_delegate.was_acked());
   std::unique_ptr<ui::Event> ui_event(
       new ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), ui::EF_NONE, 0));
   window_tree_client()->OnWindowInputEvent(
       InputEventBasicTestWindowDelegate::kEventId, server_id(top_level.get()),
       ui::Event::Clone(*ui_event.get()), 0);
   EXPECT_TRUE(window_tree()->WasEventAcked(1));
   EXPECT_TRUE(window_delegate.got_move());
@@ skipping 245 matching lines @@
 
 TEST_F(WindowTreeClientClientTest, NewTopLevelWindowGetsPropertiesFromData) {
   const size_t initial_root_count =
       window_tree_client_impl()->GetRoots().size();
   std::unique_ptr<Window> top_level(base::MakeUnique<Window>(nullptr));
   top_level->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   top_level->Init(ui::LAYER_NOT_DRAWN);
   EXPECT_EQ(initial_root_count + 1,
             window_tree_client_impl()->GetRoots().size());
 
-  // TODO: check drawn.
-  // EXPECT_FALSE(root2->IsDrawn());
+  EXPECT_FALSE(IsWindowHostVisible(top_level.get()));
   EXPECT_FALSE(top_level->TargetVisibility());
 
   // Ack the request to the windowtree to create the new window.
   EXPECT_EQ(window_tree()->window_id(), server_id(top_level.get()));
 
   ui::mojom::WindowDataPtr data = ui::mojom::WindowData::New();
   data->window_id = server_id(top_level.get());
   data->bounds.SetRect(1, 2, 3, 4);
   data->visible = true;
   const int64_t display_id = 1;
   uint32_t change_id;
   ASSERT_TRUE(window_tree()->GetAndRemoveFirstChangeOfType(
       WindowTreeChangeType::NEW_TOP_LEVEL, &change_id));
   window_tree_client()->OnTopLevelCreated(change_id, std::move(data),
                                           display_id, true);
 
   // Make sure all the properties took.
-  // EXPECT_TRUE(root2->IsDrawn());
+  EXPECT_TRUE(IsWindowHostVisible(top_level.get()));
   EXPECT_TRUE(top_level->TargetVisibility());
   // TODO: check display_id.
   // EXPECT_EQ(1, root2->display_id());
-  EXPECT_EQ(gfx::Rect(1, 2, 3, 4), top_level->bounds());
+  EXPECT_EQ(gfx::Rect(0, 0, 3, 4), top_level->bounds());
+  EXPECT_EQ(gfx::Rect(1, 2, 3, 4), top_level->GetHost()->GetBounds());
 }
 
 TEST_F(WindowTreeClientClientTest, NewWindowGetsAllChangesInFlight) {
   SetPropertyConverter(base::MakeUnique<TestPropertyConverter>());
 
-  Window window(nullptr);
-  window.Init(ui::LAYER_NOT_DRAWN);
+  std::unique_ptr<Window> top_level(base::MakeUnique<Window>(nullptr));
+  top_level->SetType(ui::wm::WINDOW_TYPE_NORMAL);
+  top_level->Init(ui::LAYER_NOT_DRAWN);
 
-  EXPECT_FALSE(window.TargetVisibility());
+  EXPECT_FALSE(top_level->TargetVisibility());
 
   // Make visibility go from false->true->false. Don't ack immediately.
-  window.Show();
-  window.Hide();
+  top_level->Show();
+  top_level->Hide();
 
   // Change bounds to 5, 6, 7, 8.
-  window.SetBounds(gfx::Rect(5, 6, 7, 8));
+  top_level->SetBounds(gfx::Rect(5, 6, 7, 8));
 
   const uint8_t explicitly_set_test_property1_value = 2;
-  window.SetProperty(kTestPropertyKey1, explicitly_set_test_property1_value);
+  top_level->SetProperty(kTestPropertyKey1,
+                         explicitly_set_test_property1_value);
 
-  // Ack the new window top level window. Vis and bounds shouldn't change.
+  // Ack the new window top level top_level Vis and bounds shouldn't change.
   ui::mojom::WindowDataPtr data = ui::mojom::WindowData::New();
-  data->window_id = server_id(&window);
-  data->bounds.SetRect(1, 2, 3, 4);
+  data->window_id = server_id(top_level.get());
+  const gfx::Rect bounds_from_server(1, 2, 3, 4);
+  data->bounds = bounds_from_server;
   data->visible = true;
   const uint8_t server_test_property1_value = 3;
   data->properties[kTestPropertyServerKey1] =
       Uint8ToPropertyTransportValue(server_test_property1_value);
   const uint8_t server_test_property2_value = 4;
   data->properties[kTestPropertyServerKey2] =
       Uint8ToPropertyTransportValue(server_test_property2_value);
   const int64_t display_id = 1;
-  // Get the id of the in flight change for creating the new window.
+  // Get the id of the in flight change for creating the new top_level.
   uint32_t new_window_in_flight_change_id;
   ASSERT_TRUE(window_tree()->GetAndRemoveFirstChangeOfType(
-      WindowTreeChangeType::NEW_WINDOW, &new_window_in_flight_change_id));
+      WindowTreeChangeType::NEW_TOP_LEVEL, &new_window_in_flight_change_id));
   window_tree_client()->OnTopLevelCreated(new_window_in_flight_change_id,
                                           std::move(data), display_id, true);
 
   // The only value that should take effect is the property for 'yy' as it was
   // not in flight.
-  EXPECT_FALSE(window.TargetVisibility());
-  EXPECT_EQ(gfx::Rect(5, 6, 7, 8), window.bounds());
+  EXPECT_FALSE(top_level->TargetVisibility());
+  EXPECT_EQ(gfx::Rect(5, 6, 7, 8), top_level->bounds());
   EXPECT_EQ(explicitly_set_test_property1_value,
-            window.GetProperty(kTestPropertyKey1));
-  EXPECT_EQ(server_test_property2_value, window.GetProperty(kTestPropertyKey2));
+            top_level->GetProperty(kTestPropertyKey1));
+  EXPECT_EQ(server_test_property2_value,
+            top_level->GetProperty(kTestPropertyKey2));
 
   // Tell the client the changes failed. This should cause the values to change
   // to that of the server.
   ASSERT_TRUE(window_tree()->AckFirstChangeOfType(WindowTreeChangeType::VISIBLE,
                                                   false));
-  EXPECT_FALSE(window.TargetVisibility());
+  EXPECT_FALSE(top_level->TargetVisibility());
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::VISIBLE, false));
-  EXPECT_TRUE(window.TargetVisibility());
+  EXPECT_TRUE(top_level->TargetVisibility());
   window_tree()->AckAllChangesOfType(WindowTreeChangeType::BOUNDS, false);
-  EXPECT_EQ(gfx::Rect(1, 2, 3, 4), window.bounds());
+  // The bounds of the top_level is always at the origin.
+  EXPECT_EQ(gfx::Rect(bounds_from_server.size()), top_level->bounds());
+  // But the bounds of the WindowTreeHost is display relative.
+  EXPECT_EQ(bounds_from_server,
+            top_level->GetRootWindow()->GetHost()->GetBounds());
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, false));
-  EXPECT_EQ(server_test_property1_value, window.GetProperty(kTestPropertyKey1));
-  EXPECT_EQ(server_test_property2_value, window.GetProperty(kTestPropertyKey2));
+  EXPECT_EQ(server_test_property1_value,
+            top_level->GetProperty(kTestPropertyKey1));
+  EXPECT_EQ(server_test_property2_value,
+            top_level->GetProperty(kTestPropertyKey2));
 }
 
 TEST_F(WindowTreeClientClientTest, NewWindowGetsProperties) {
   SetPropertyConverter(base::MakeUnique<TestPropertyConverter>());
   Window window(nullptr);
   const uint8_t explicitly_set_test_property1_value = 29;
   window.SetProperty(kTestPropertyKey1, explicitly_set_test_property1_value);
   window.Init(ui::LAYER_NOT_DRAWN);
   mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties =
       window_tree()->GetLastNewWindowProperties();
@@ skipping 243 matching lines @@
 
   // Changes originating from server should notify observers too.
   window_tree_client()->OnCaptureChanged(server_id(&child2), 0);
   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();
 }
 
 }  // namespace aura