Expand aura::PropertyConverter support.

ui/aura/mus/property_converter_unittest.cc

Index: ui/aura/mus/property_converter_unittest.cc
diff --git a/ui/aura/mus/property_converter_unittest.cc b/ui/aura/mus/property_converter_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d64a88b78c4647234e34d84aa1e25e29d990d62e
--- /dev/null
+++ b/ui/aura/mus/property_converter_unittest.cc
@@ -0,0 +1,197 @@
+// Copyright 2016 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/property_converter.h"
+
+#include <stdint.h>
+#include <string>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "services/ui/public/cpp/property_type_converters.h"
+#include "ui/aura/test/aura_test_base.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_property.h"
+#include "ui/gfx/geometry/rect.h"
+
+// See aura_constants.cc for bool, int32_t, int64_t, std::string, and gfx::Rect.
+// That same file also declares the uint32_t type via SkColor.
+DECLARE_WINDOW_PROPERTY_TYPE(uint8_t)
+DECLARE_WINDOW_PROPERTY_TYPE(uint16_t)
+DECLARE_WINDOW_PROPERTY_TYPE(uint64_t)
+DECLARE_WINDOW_PROPERTY_TYPE(int8_t)
+DECLARE_WINDOW_PROPERTY_TYPE(int16_t)
+
+namespace aura {
+
+namespace {
+
+DEFINE_WINDOW_PROPERTY_KEY(bool, kTestPropertyKey0, false);
+DEFINE_WINDOW_PROPERTY_KEY(uint8_t, kTestPropertyKey1, 0);
+DEFINE_WINDOW_PROPERTY_KEY(uint16_t, kTestPropertyKey2, 0);
+DEFINE_WINDOW_PROPERTY_KEY(uint32_t, kTestPropertyKey3, 0);
+DEFINE_WINDOW_PROPERTY_KEY(uint64_t, kTestPropertyKey4, 0);
+DEFINE_WINDOW_PROPERTY_KEY(int8_t, kTestPropertyKey5, 0);
+DEFINE_WINDOW_PROPERTY_KEY(int16_t, kTestPropertyKey6, 0);
+DEFINE_WINDOW_PROPERTY_KEY(int32_t, kTestPropertyKey7, 0);
+DEFINE_WINDOW_PROPERTY_KEY(int64_t, kTestPropertyKey8, 0);
+
+DEFINE_WINDOW_PROPERTY_KEY(gfx::Rect*, kTestRectPropertyKey, nullptr);
+DEFINE_WINDOW_PROPERTY_KEY(std::string*, kTestStringPropertyKey, nullptr);
+
+const char kTestPropertyServerKey0[] = "test-property-server0";
+const char kTestPropertyServerKey1[] = "test-property-server1";
+const char kTestPropertyServerKey2[] = "test-property-server2";
+const char kTestPropertyServerKey3[] = "test-property-server3";
+const char kTestPropertyServerKey4[] = "test-property-server4";
+const char kTestPropertyServerKey5[] = "test-property-server5";
+const char kTestPropertyServerKey6[] = "test-property-server6";
+const char kTestPropertyServerKey7[] = "test-property-server7";
+const char kTestPropertyServerKey8[] = "test-property-server8";
+
+const char kTestRectPropertyServerKey[] = "test-rect-property-server";
+const char kTestStringPropertyServerKey[] = "test-string-property-server";
+
+// Test registration, naming and value conversion for primitive property types.
+template <typename T>
+void TestPrimitiveProperty(PropertyConverter* property_converter,
+                           Window* window,
+                           const WindowProperty<T>* key,
+                           const char* transport_name,
+                           T value_1,
+                           T value_2) {
+  property_converter->RegisterProperty(key, transport_name);
+  EXPECT_EQ(transport_name,
+            property_converter->GetTransportNameForPropertyKey(key));
+
+  window->SetProperty(key, value_1);
+  EXPECT_EQ(value_1, window->GetProperty(key));
+
+  std::string transport_name_out;
+  std::unique_ptr<std::vector<uint8_t>> transport_value_out;
+  EXPECT_TRUE(property_converter->ConvertPropertyForTransport(
+      window, key, &transport_name_out, &transport_value_out));
+  EXPECT_EQ(transport_name, transport_name_out);
+  const int64_t storage_value_1 = static_cast<int64_t>(value_1);
+  std::vector<uint8_t> transport_value1 =
+      mojo::ConvertTo<std::vector<uint8_t>>(storage_value_1);
+  EXPECT_EQ(transport_value1, *transport_value_out.get());
+
+  const int64_t storage_value_2 = static_cast<int64_t>(value_2);
+  std::vector<uint8_t> transport_value2 =
+      mojo::ConvertTo<std::vector<uint8_t>>(storage_value_2);
+  property_converter->SetPropertyFromTransportValue(window, transport_name,
+                                                    &transport_value2);
+  EXPECT_EQ(value_2, window->GetProperty(key));
+}
+
+}  // namespace
+
+using PropertyConverterTest = test::AuraTestBase;
+
+// Verifies property setting behavior for a std::string* property.
+TEST_F(PropertyConverterTest, PrimitiveProperties) {
+  PropertyConverter property_converter;
+  std::unique_ptr<Window> window(CreateNormalWindow(1, root_window(), nullptr));
+
+  const bool value_0a = true, value_0b = false;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey0,
+                        kTestPropertyServerKey0, value_0a, value_0b);
+
+  const uint8_t value_1a = UINT8_MAX / 2, value_1b = UINT8_MAX / 3;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey1,
+                        kTestPropertyServerKey1, value_1a, value_1b);
+
+  const uint16_t value_2a = UINT16_MAX / 3, value_2b = UINT16_MAX / 4;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey2,
+                        kTestPropertyServerKey2, value_2a, value_2b);
+
+  const uint32_t value_3a = UINT32_MAX / 4, value_3b = UINT32_MAX / 5;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey3,
+                        kTestPropertyServerKey3, value_3a, value_3b);
+
+  const uint64_t value_4a = UINT64_MAX / 5, value_4b = UINT64_MAX / 6;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey4,
+                        kTestPropertyServerKey4, value_4a, value_4b);
+
+  const int8_t value_5a = INT8_MIN / 2, value_5b = INT8_MIN / 3;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey5,
+                        kTestPropertyServerKey5, value_5a, value_5b);
+
+  const int16_t value_6a = INT16_MIN / 3, value_6b = INT16_MIN / 4;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey6,
+                        kTestPropertyServerKey6, value_6a, value_6b);
+
+  const int32_t value_7a = INT32_MIN / 4, value_7b = INT32_MIN / 5;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey7,
+                        kTestPropertyServerKey7, value_7a, value_7b);
+
+  const int64_t value_8a = INT64_MIN / 5, value_8b = INT64_MIN / 6;
+  TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey8,
+                        kTestPropertyServerKey8, value_8a, value_8b);
+}
+
+// Verifies property setting behavior for a gfx::Rect* property.
+TEST_F(PropertyConverterTest, RectProperty) {
+  PropertyConverter property_converter;
+  property_converter.RegisterProperty(kTestRectPropertyKey,
+                                      kTestRectPropertyServerKey);
+  EXPECT_EQ(
+      kTestRectPropertyServerKey,
+      property_converter.GetTransportNameForPropertyKey(kTestRectPropertyKey));
+
+  gfx::Rect value_1(1, 2, 3, 4);
+  std::unique_ptr<Window> window(CreateNormalWindow(1, root_window(), nullptr));
+  window->SetProperty(kTestRectPropertyKey, new gfx::Rect(value_1));
+  EXPECT_EQ(value_1, *window->GetProperty(kTestRectPropertyKey));
+
+  std::string transport_name_out;
+  std::unique_ptr<std::vector<uint8_t>> transport_value_out;
+  EXPECT_TRUE(property_converter.ConvertPropertyForTransport(
+      window.get(), kTestRectPropertyKey, &transport_name_out,
+      &transport_value_out));
+  EXPECT_EQ(kTestRectPropertyServerKey, transport_name_out);
+  EXPECT_EQ(mojo::ConvertTo<std::vector<uint8_t>>(value_1),
+            *transport_value_out.get());
+
+  gfx::Rect value_2(1, 3, 5, 7);
+  std::vector<uint8_t> transport_value =
+      mojo::ConvertTo<std::vector<uint8_t>>(value_2);
+  property_converter.SetPropertyFromTransportValue(
+      window.get(), kTestRectPropertyServerKey, &transport_value);
+  EXPECT_EQ(value_2, *window->GetProperty(kTestRectPropertyKey));
+}
+
+// Verifies property setting behavior for a std::string* property.
+TEST_F(PropertyConverterTest, StringProperty) {
+  PropertyConverter property_converter;
+  property_converter.RegisterProperty(kTestStringPropertyKey,
+                                      kTestStringPropertyServerKey);
+  EXPECT_EQ(kTestStringPropertyServerKey,
+            property_converter.GetTransportNameForPropertyKey(
+                kTestStringPropertyKey));
+
+  std::string value_1 = "test value";
+  std::unique_ptr<Window> window(CreateNormalWindow(1, root_window(), nullptr));
+  window->SetProperty(kTestStringPropertyKey, new std::string(value_1));
+  EXPECT_EQ(value_1, *window->GetProperty(kTestStringPropertyKey));
+
+  std::string transport_name_out;
+  std::unique_ptr<std::vector<uint8_t>> transport_value_out;
+  EXPECT_TRUE(property_converter.ConvertPropertyForTransport(
+      window.get(), kTestStringPropertyKey, &transport_name_out,
+      &transport_value_out));
+  EXPECT_EQ(kTestStringPropertyServerKey, transport_name_out);
+  EXPECT_EQ(mojo::ConvertTo<std::vector<uint8_t>>(value_1),
+            *transport_value_out.get());
+
+  std::string value_2 = "another test value";
+  std::vector<uint8_t> transport_value =
+      mojo::ConvertTo<std::vector<uint8_t>>(value_2);
+  property_converter.SetPropertyFromTransportValue(
+      window.get(), kTestStringPropertyServerKey, &transport_value);
+  EXPECT_EQ(value_2, *window->GetProperty(kTestStringPropertyKey));
+}
+
+}  // namespace aura