mash: wires up shadows for mash

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 62 matching lines @@
 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));
+  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(
       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);
@@ skipping 20 matching lines @@
 
 }  // 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(
+      property_converter.IsTransportNameRegistered(kTestPropertyServerKey0));
+
   const bool value_0a = true, value_0b = false;
   TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey0,
                         kTestPropertyServerKey0, value_0a, value_0b);
 
   const bool value_1a = true, value_1b = false;
   TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey1,
                         kTestPropertyServerKey1, value_1a, value_1b);
 
   const uint8_t value_2a = UINT8_MAX / 2, value_2b = UINT8_MAX / 3;
   TestPrimitiveProperty(&property_converter, window.get(), kTestPropertyKey2,
@@ skipping 29 matching lines @@
 }
 
 // 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));
 
   SkBitmap bitmap_1;
   bitmap_1.allocN32Pixels(16, 32);
   bitmap_1.eraseARGB(255, 11, 22, 33);
   gfx::ImageSkia value_1 = gfx::ImageSkia::CreateFrom1xBitmap(bitmap_1);
   std::unique_ptr<Window> window(CreateNormalWindow(1, root_window(), nullptr));
   window->SetProperty(kTestImagePropertyKey, new gfx::ImageSkia(value_1));
   gfx::ImageSkia* image_out_1 = window->GetProperty(kTestImagePropertyKey);
   EXPECT_TRUE(gfx::BitmapsAreEqual(bitmap_1, *image_out_1->bitmap()));
 
@@ skipping 20 matching lines @@
 }
 
 // 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));
+  EXPECT_TRUE(
+      property_converter.IsTransportNameRegistered(kTestRectPropertyServerKey));
 
   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,
@@ skipping 11 matching lines @@
 }
 
 // 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));
+  EXPECT_TRUE(
+      property_converter.IsTransportNameRegistered(kTestSizePropertyServerKey));
 
   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,
@@ skipping 11 matching lines @@
 }
 
 // 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));
+  EXPECT_TRUE(property_converter.IsTransportNameRegistered(
+      kTestStringPropertyServerKey));
 
   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,
@@ skipping 11 matching lines @@
 }
 
 // Verifies property setting behavior for a base::string16* property.
 TEST_F(PropertyConverterTest, String16Property) {
   PropertyConverter property_converter;
   property_converter.RegisterProperty(kTestString16PropertyKey,
                                       kTestString16PropertyServerKey);
   EXPECT_EQ(kTestString16PropertyServerKey,
             property_converter.GetTransportNameForPropertyKey(
                 kTestString16PropertyKey));
+  EXPECT_TRUE(property_converter.IsTransportNameRegistered(
+      kTestString16PropertyServerKey));
 
   base::string16 value_1 = base::ASCIIToUTF16("test value");
   std::unique_ptr<Window> window(CreateNormalWindow(1, root_window(), nullptr));
   window->SetProperty(kTestString16PropertyKey, new base::string16(value_1));
   EXPECT_EQ(value_1, *window->GetProperty(kTestString16PropertyKey));
 
   std::string transport_name_out;
   std::unique_ptr<std::vector<uint8_t>> transport_value_out;
   EXPECT_TRUE(property_converter.ConvertPropertyForTransport(
       window.get(), kTestString16PropertyKey, &transport_name_out,
       &transport_value_out));
   EXPECT_EQ(kTestString16PropertyServerKey, transport_name_out);
   EXPECT_EQ(mojo::ConvertTo<std::vector<uint8_t>>(value_1),
             *transport_value_out.get());
 
   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