Validate incoming window properties.

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 59 matching lines @@
 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);
+  property_converter->RegisterProperty(
+      key, transport_name, PropertyConverter::CreateAcceptAnyValueCallback());
   EXPECT_EQ(transport_name,
             property_converter->GetTransportNameForPropertyKey(key));
   EXPECT_TRUE(property_converter->IsTransportNameRegistered(transport_name));
 
   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(
@@ skipping 14 matching lines @@
       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));
 }
 
+bool OnlyAllowNegativeNumbers(int64_t number) {
+  return number < 0;
+}
+
 }  // 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));
 
   EXPECT_FALSE(
@@ skipping 33 matching lines @@
 
   const int32_t value_8a = INT32_MIN / 4, value_8b = INT32_MIN / 5;
   TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey8,
                         kTestPropertyServerKey8, value_8a, value_8b);
 
   const int64_t value_9a = INT64_MIN / 5, value_9b = INT64_MIN / 6;
   TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey9,
                         kTestPropertyServerKey9, value_9a, value_9b);
 }
 
+TEST_F(PropertyConverterTest, TestPrimitiveVerifier) {
+  std::unique_ptr<Window> window(CreateNormalWindow(1, root_window(), nullptr));
+
+  PropertyConverter property_converter;
+  property_converter.RegisterProperty(kTestPropertyKey8,
+                                      kTestPropertyServerKey8,
+                                      base::Bind(&OnlyAllowNegativeNumbers));
+
+  // Test that we reject invalid TransportValues during
+  // GetPropertyValueFromTransportValue().
+  int64_t int_value = 5;
+  std::vector<uint8_t> transport =
+      mojo::ConvertTo<std::vector<uint8_t>>(int_value);
+  EXPECT_FALSE(property_converter.GetPropertyValueFromTransportValue(
+      kTestPropertyServerKey8, transport, &int_value));
+
+  // Test that we reject invalid TransportValues during
+  // SetPropertyFromTransportValue().
+  EXPECT_EQ(-1, window->GetProperty(kTestPropertyKey8));
+  property_converter.SetPropertyFromTransportValue(
+      window.get(), kTestPropertyServerKey8, &transport);
+  EXPECT_EQ(-1, window->GetProperty(kTestPropertyKey8));
+}
+
 // Verifies property setting behavior for a gfx::ImageSkia* property.
 TEST_F(PropertyConverterTest, ImageSkiaProperty) {
   PropertyConverter property_converter;
   property_converter.RegisterProperty(kTestImagePropertyKey,
                                       kTestImagePropertyServerKey);
   EXPECT_EQ(
       kTestImagePropertyServerKey,
       property_converter.GetTransportNameForPropertyKey(kTestImagePropertyKey));
   EXPECT_TRUE(property_converter.IsTransportNameRegistered(
       kTestImagePropertyServerKey));
@@ skipping 155 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