Mojo C++ bindings: switch services/ui/public/interfaces mojom target to use STL types.

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"
@@ skipping 56 matching lines @@
 
 // Register some test window properties for aura/mus conversion.
 void RegisterTestProperties(PropertyConverter* converter) {
   converter->RegisterProperty(kTestPropertyKey1, kTestPropertyServerKey1);
   converter->RegisterProperty(kTestPropertyKey2, kTestPropertyServerKey2);
   converter->RegisterProperty(kTestPropertyKey3, kTestPropertyServerKey3);
 }
 
 // Convert a primitive aura property value to a mus transport value.
 // Note that this implicitly casts arguments to the aura storage type, int64_t.
-mojo::Array<uint8_t> ConvertToPropertyTransportValue(int64_t value) {
-  return mojo::Array<uint8_t>(mojo::ConvertTo<std::vector<uint8_t>>(value));
+std::vector<uint8_t> ConvertToPropertyTransportValue(int64_t value) {
+  return mojo::ConvertTo<std::vector<uint8_t>>(value);
 }
 
 }  // namespace
 
 using WindowTreeClientWmTest = test::AuraMusWmTestBase;
 using WindowTreeClientClientTest = test::AuraMusClientTestBase;
 
 // Verifies bounds are reverted if the server replied that the change failed.
 TEST_F(WindowTreeClientWmTest, SetBoundsFailed) {
   Window window(nullptr);
@@ skipping 10 matching lines @@
 
 // Verifies a new window from the server doesn't result in attempting to add
 // the window back to the server.
 TEST_F(WindowTreeClientWmTest, AddFromServerDoesntAddAgain) {
   const Id child_window_id = server_id(root_window()) + 11;
   ui::mojom::WindowDataPtr data = ui::mojom::WindowData::New();
   data->parent_id = server_id(root_window());
   data->window_id = child_window_id;
   data->bounds = gfx::Rect(1, 2, 3, 4);
   data->visible = false;
-  mojo::Array<ui::mojom::WindowDataPtr> data_array(1);
+  std::vector<ui::mojom::WindowDataPtr> data_array(1);
   data_array[0] = std::move(data);
   ASSERT_TRUE(root_window()->children().empty());
   window_tree_client()->OnWindowHierarchyChanged(
       child_window_id, 0, server_id(root_window()), std::move(data_array));
   ASSERT_FALSE(window_tree()->has_change());
   ASSERT_EQ(1u, root_window()->children().size());
   Window* child = root_window()->children()[0];
   EXPECT_FALSE(child->TargetVisibility());
 }
 
 // Verifies a reparent from the server doesn't attempt signal the server.
 TEST_F(WindowTreeClientWmTest, ReparentFromServerDoesntAddAgain) {
   Window window1(nullptr);
   window1.Init(ui::LAYER_NOT_DRAWN);
   Window window2(nullptr);
   window2.Init(ui::LAYER_NOT_DRAWN);
   root_window()->AddChild(&window1);
   root_window()->AddChild(&window2);
 
   window_tree()->AckAllChanges();
   // Simulate moving |window1| to be a child of |window2| from the server.
-  window_tree_client()->OnWindowHierarchyChanged(server_id(&window1),
-                                                 server_id(root_window()),
-                                                 server_id(&window2), nullptr);
+  window_tree_client()->OnWindowHierarchyChanged(
+      server_id(&window1), server_id(root_window()), server_id(&window2),
+      std::vector<ui::mojom::WindowDataPtr>());
   ASSERT_FALSE(window_tree()->has_change());
   EXPECT_EQ(&window2, window1.parent());
   EXPECT_EQ(root_window(), window2.parent());
   window1.parent()->RemoveChild(&window1);
 }
 
 // Verifies properties passed in OnWindowHierarchyChanged() make there way to
 // the new window.
 TEST_F(WindowTreeClientWmTest, OnWindowHierarchyChangedWithProperties) {
   RegisterTestProperties(GetPropertyConverter());
   window_tree()->AckAllChanges();
   const Id child_window_id = server_id(root_window()) + 11;
   ui::mojom::WindowDataPtr data = ui::mojom::WindowData::New();
   const uint8_t server_test_property1_value = 91;
   data->properties[kTestPropertyServerKey1] =
       ConvertToPropertyTransportValue(server_test_property1_value);
   data->parent_id = server_id(root_window());
   data->window_id = child_window_id;
   data->bounds = gfx::Rect(1, 2, 3, 4);
   data->visible = false;
-  mojo::Array<ui::mojom::WindowDataPtr> data_array(1);
+  std::vector<ui::mojom::WindowDataPtr> data_array(1);
   data_array[0] = std::move(data);
   ASSERT_TRUE(root_window()->children().empty());
   window_tree_client()->OnWindowHierarchyChanged(
       child_window_id, 0, server_id(root_window()), std::move(data_array));
   ASSERT_FALSE(window_tree()->has_change());
   ASSERT_EQ(1u, root_window()->children().size());
   Window* child = root_window()->children()[0];
   EXPECT_FALSE(child->TargetVisibility());
   EXPECT_EQ(server_test_property1_value, child->GetProperty(kTestPropertyKey1));
 }
@@ skipping 85 matching lines @@
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(WindowTreeChangeType::BOUNDS,
                                                    false));
   EXPECT_EQ(original_bounds, root_window()->bounds());
 }
 
 // Verifies properties are set if the server replied that the change succeeded.
 TEST_F(WindowTreeClientWmTest, SetPropertySucceeded) {
   ASSERT_FALSE(root_window()->GetProperty(client::kAlwaysOnTopKey));
   root_window()->SetProperty(client::kAlwaysOnTopKey, true);
   EXPECT_TRUE(root_window()->GetProperty(client::kAlwaysOnTopKey));
-  mojo::Array<uint8_t> value = window_tree()->GetLastPropertyValue();
-  ASSERT_FALSE(value.is_null());
+  base::Optional<std::vector<uint8_t>> value =
+      window_tree()->GetLastPropertyValue();
+  ASSERT_TRUE(value.has_value());
   // PropertyConverter uses int64_t values, even for smaller types, like bool.
-  ASSERT_EQ(8u, value.size());
-  EXPECT_EQ(1, mojo::ConvertTo<int64_t>(value.PassStorage()));
+  ASSERT_EQ(8u, value->size());
+  EXPECT_EQ(1, mojo::ConvertTo<int64_t>(*value));
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, true));
   EXPECT_TRUE(root_window()->GetProperty(client::kAlwaysOnTopKey));
 }
 
 // Verifies properties are reverted if the server replied that the change
 // failed.
 TEST_F(WindowTreeClientWmTest, SetPropertyFailed) {
   ASSERT_FALSE(root_window()->GetProperty(client::kAlwaysOnTopKey));
   root_window()->SetProperty(client::kAlwaysOnTopKey, true);
   EXPECT_TRUE(root_window()->GetProperty(client::kAlwaysOnTopKey));
-  mojo::Array<uint8_t> value = window_tree()->GetLastPropertyValue();
-  ASSERT_FALSE(value.is_null());
+  base::Optional<std::vector<uint8_t>> value =
+      window_tree()->GetLastPropertyValue();
+  ASSERT_TRUE(value.has_value());
   // PropertyConverter uses int64_t values, even for smaller types, like bool.
-  ASSERT_EQ(8u, value.size());
-  EXPECT_EQ(1, mojo::ConvertTo<int64_t>(value.PassStorage()));
+  ASSERT_EQ(8u, value->size());
+  EXPECT_EQ(1, mojo::ConvertTo<int64_t>(*value));
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, false));
   EXPECT_FALSE(root_window()->GetProperty(client::kAlwaysOnTopKey));
 }
 
 // Simulates a property change, and while the property change is in flight the
 // server replies with a new property and the original property change fails.
 TEST_F(WindowTreeClientWmTest, SetPropertyFailedWithPendingChange) {
   RegisterTestProperties(GetPropertyConverter());
   const uint8_t value1 = 11;
@@ skipping 59 matching lines @@
       WindowTreeChangeType::PROPERTY, false));
   EXPECT_FALSE(root_window()->GetProperty(kTestPropertyKey3));
 }
 
 // Verifies property setting behavior for a gfx::Rect* property.
 TEST_F(WindowTreeClientWmTest, SetRectProperty) {
   gfx::Rect example(1, 2, 3, 4);
   ASSERT_EQ(nullptr, root_window()->GetProperty(client::kRestoreBoundsKey));
   root_window()->SetProperty(client::kRestoreBoundsKey, new gfx::Rect(example));
   EXPECT_TRUE(root_window()->GetProperty(client::kRestoreBoundsKey));
-  mojo::Array<uint8_t> value = window_tree()->GetLastPropertyValue();
-  ASSERT_FALSE(value.is_null());
-  EXPECT_EQ(example, mojo::ConvertTo<gfx::Rect>(value.PassStorage()));
+  base::Optional<std::vector<uint8_t>> value =
+      window_tree()->GetLastPropertyValue();
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(example, mojo::ConvertTo<gfx::Rect>(*value));
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, true));
   EXPECT_EQ(example, *root_window()->GetProperty(client::kRestoreBoundsKey));
 
   root_window()->SetProperty(client::kRestoreBoundsKey, new gfx::Rect());
   EXPECT_EQ(gfx::Rect(),
             *root_window()->GetProperty(client::kRestoreBoundsKey));
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, false));
   EXPECT_EQ(example, *root_window()->GetProperty(client::kRestoreBoundsKey));
 }
 
 // Verifies property setting behavior for a std::string* property.
 TEST_F(WindowTreeClientWmTest, SetStringProperty) {
   std::string example = "123";
   ASSERT_EQ(nullptr, root_window()->GetProperty(client::kAppIdKey));
   root_window()->SetProperty(client::kAppIdKey, new std::string(example));
   EXPECT_TRUE(root_window()->GetProperty(client::kAppIdKey));
-  mojo::Array<uint8_t> value = window_tree()->GetLastPropertyValue();
-  ASSERT_FALSE(value.is_null());
-  EXPECT_EQ(example, mojo::ConvertTo<std::string>(value.PassStorage()));
+  base::Optional<std::vector<uint8_t>> value =
+      window_tree()->GetLastPropertyValue();
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(example, mojo::ConvertTo<std::string>(*value));
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, true));
   EXPECT_EQ(example, *root_window()->GetProperty(client::kAppIdKey));
 
   root_window()->SetProperty(client::kAppIdKey, new std::string());
   EXPECT_EQ(std::string(), *root_window()->GetProperty(client::kAppIdKey));
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, false));
   EXPECT_EQ(example, *root_window()->GetProperty(client::kAppIdKey));
 }
@@ skipping 458 matching lines @@
   EXPECT_EQ(server_test_property2_value,
             top_level->GetProperty(kTestPropertyKey2));
 }
 
 TEST_F(WindowTreeClientClientTest, NewWindowGetsProperties) {
   RegisterTestProperties(GetPropertyConverter());
   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();
-  ASSERT_FALSE(transport_properties.is_null());
+  base::Optional<std::unordered_map<std::string, std::vector<uint8_t>>>
+      transport_properties = window_tree()->GetLastNewWindowProperties();
+  ASSERT_TRUE(transport_properties.has_value());
   std::map<std::string, std::vector<uint8_t>> properties =
-      transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
+      mojo::UnorderedMapToMap(*transport_properties);
   ASSERT_EQ(1u, properties.count(kTestPropertyServerKey1));
   // PropertyConverter uses int64_t values, even for smaller types like uint8_t.
   ASSERT_EQ(8u, properties[kTestPropertyServerKey1].size());
   EXPECT_EQ(static_cast<int64_t>(explicitly_set_test_property1_value),
             mojo::ConvertTo<int64_t>(properties[kTestPropertyServerKey1]));
   ASSERT_EQ(0u, properties.count(kTestPropertyServerKey2));
 }
 
 // Assertions around transient windows.
 TEST_F(WindowTreeClientClientTest, Transients) {
@@ skipping 70 matching lines @@
   // Verify the property made it to the window.
   EXPECT_EQ(property_value,
             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 property was sent to the server.
-  mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties =
-      window_tree()->GetLastNewWindowProperties();
-  ASSERT_FALSE(transport_properties.is_null());
+  base::Optional<std::unordered_map<std::string, std::vector<uint8_t>>>
+      transport_properties = window_tree()->GetLastNewWindowProperties();
+  ASSERT_TRUE(transport_properties.has_value());
   std::map<std::string, std::vector<uint8_t>> properties2 =
-      transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
+      mojo::UnorderedMapToMap(*transport_properties);
   ASSERT_EQ(1u, properties2.count(kTestPropertyServerKey1));
   // PropertyConverter uses int64_t values, even for smaller types like uint8_t.
   ASSERT_EQ(8u, properties2[kTestPropertyServerKey1].size());
   EXPECT_EQ(static_cast<int64_t>(property_value),
             mojo::ConvertTo<int64_t>(properties2[kTestPropertyServerKey1]));
 }
 
 // Tests both SetCapture and ReleaseCapture, to ensure that Window is properly
 // updated on failures.
 TEST_F(WindowTreeClientWmTest, ExplicitCapture) {
@@ skipping 232 matching lines @@
   ui::mojom::WindowDataPtr data3 = ui::mojom::WindowData::New();
   data1->parent_id = server_id(root_window());
   data1->window_id = server_window_id;
   data1->bounds = gfx::Rect(1, 2, 3, 4);
   data2->parent_id = server_window_id;
   data2->window_id = WindowMus::Get(window1)->server_id();
   data2->bounds = gfx::Rect(1, 2, 3, 4);
   data3->parent_id = server_window_id;
   data3->window_id = WindowMus::Get(window2)->server_id();
   data3->bounds = gfx::Rect(1, 2, 3, 4);
-  mojo::Array<ui::mojom::WindowDataPtr> data_array(3);
+  std::vector<ui::mojom::WindowDataPtr> data_array(3);
   data_array[0] = std::move(data1);
   data_array[1] = std::move(data2);
   data_array[2] = std::move(data3);
   window_tree_client()->OnWindowHierarchyChanged(
       server_window_id, 0, server_id(root_window()), std::move(data_array));
   ASSERT_FALSE(window_tree()->has_change());
   ASSERT_EQ(1u, root_window()->children().size());
   Window* server_window = root_window()->children()[0];
   EXPECT_EQ(window1->parent(), server_window);
   EXPECT_EQ(window2->parent(), server_window);
   ASSERT_EQ(2u, server_window->children().size());
   EXPECT_EQ(window1, server_window->children()[0]);
   EXPECT_EQ(window2, server_window->children()[1]);
 }
 
 }  // namespace aura