Adds a couple more properties to the property converter

ui/aura/mus/property_converter_unittest.cc

 // 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"
@@ skipping 27 matching lines @@
 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_OWNED_WINDOW_PROPERTY_KEY(gfx::ImageSkia, kTestImagePropertyKey,
                                  nullptr);
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(gfx::Rect, kTestRectPropertyKey, nullptr);
+DEFINE_OWNED_WINDOW_PROPERTY_KEY(gfx::Size, kTestSizePropertyKey, nullptr);
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(std::string, kTestStringPropertyKey, nullptr);
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(base::string16, kTestString16PropertyKey,
                                  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 kTestImagePropertyServerKey[] = "test-image-property-server";
 const char kTestRectPropertyServerKey[] = "test-rect-property-server";
+const char kTestSizePropertyServerKey[] = "test-size-property-server";
 const char kTestStringPropertyServerKey[] = "test-string-property-server";
 const char kTestString16PropertyServerKey[] = "test-string16-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());
 
+  int64_t decoded_value_1 = 0;
+  EXPECT_TRUE(property_converter->GetPropertyValueFromTransportValue(
+      transport_name, *transport_value_out, &decoded_value_1));
+  EXPECT_EQ(value_1, static_cast<T>(decoded_value_1));
+
   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));
+  int64_t decoded_value_2 = 0;
+  EXPECT_TRUE(property_converter->GetPropertyValueFromTransportValue(
+      transport_name, transport_value2, &decoded_value_2));
+  EXPECT_EQ(value_2, static_cast<T>(decoded_value_2));
 }
 
 }  // 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));
@@ skipping 99 matching lines @@
             *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 gfx::Size* property.
+TEST_F(PropertyConverterTest, SizeProperty) {
+  PropertyConverter property_converter;
+  property_converter.RegisterProperty(kTestSizePropertyKey,
+                                      kTestSizePropertyServerKey);
+  EXPECT_EQ(
+      kTestSizePropertyServerKey,
+      property_converter.GetTransportNameForPropertyKey(kTestSizePropertyKey));
+
+  gfx::Size value_1(1, 2);
+  std::unique_ptr<Window> window(CreateNormalWindow(1, root_window(), nullptr));
+  window->SetProperty(kTestSizePropertyKey, new gfx::Size(value_1));
+  EXPECT_EQ(value_1, *window->GetProperty(kTestSizePropertyKey));
+
+  std::string transport_name_out;
+  std::unique_ptr<std::vector<uint8_t>> transport_value_out;
+  EXPECT_TRUE(property_converter.ConvertPropertyForTransport(
+      window.get(), kTestSizePropertyKey, &transport_name_out,
+      &transport_value_out));
+  EXPECT_EQ(kTestSizePropertyServerKey, transport_name_out);
+  EXPECT_EQ(mojo::ConvertTo<std::vector<uint8_t>>(value_1),
+            *transport_value_out.get());
+
+  gfx::Size value_2(1, 3);
+  std::vector<uint8_t> transport_value =
+      mojo::ConvertTo<std::vector<uint8_t>>(value_2);
+  property_converter.SetPropertyFromTransportValue(
+      window.get(), kTestSizePropertyServerKey, &transport_value);
+  EXPECT_EQ(value_2, *window->GetProperty(kTestSizePropertyKey));
+}
+
 // 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";
@@ skipping 43 matching lines @@
 
   base::string16 value_2 = base::ASCIIToUTF16("another test value");
   std::vector<uint8_t> transport_value =
       mojo::ConvertTo<std::vector<uint8_t>>(value_2);
   property_converter.SetPropertyFromTransportValue(
       window.get(), kTestString16PropertyServerKey, &transport_value);
   EXPECT_EQ(value_2, *window->GetProperty(kTestString16PropertyKey));
 }
 
 }  // namespace aura