Add PropertyConverter support for non-zero default primitive values.

ui/aura/mus/property_converter.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 "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
@@ skipping 85 matching lines @@
   }
 
   auto string16_key = static_cast<const WindowProperty<base::string16*>*>(key);
   if (string16_properties_.count(string16_key) > 0) {
     *transport_value = GetArray(window, string16_key);
     return true;
   }
 
   // Handle primitive property types generically.
   DCHECK_GT(primitive_properties_.count(key), 0u);
+  PrimitiveType default_value = primitive_properties_.at(key).default_value;

[sky, 2017/01/18 04:03:09]

primitive_properties_[key].default_value?

[msw, 2017/01/18 18:00:40]

Done.

   // TODO(msw): Using the int64_t accessor is wasteful for smaller types.
-  const PrimitiveType value = window->GetPropertyInternal(key, 0);
+  const PrimitiveType value = window->GetPropertyInternal(key, default_value);
   *transport_value = base::MakeUnique<std::vector<uint8_t>>(
       mojo::ConvertTo<std::vector<uint8_t>>(value));
   return true;
 }
 
 std::string PropertyConverter::GetTransportNameForPropertyKey(const void* key) {
   if (primitive_properties_.count(key) > 0)
-    return primitive_properties_[key].second;
+    return primitive_properties_.at(key).transport_name;

[sky, 2017/01/18 04:03:09]

Same comment about using [].

[msw, 2017/01/18 18:00:40]

Done.

 
   auto image_key = static_cast<const WindowProperty<gfx::ImageSkia*>*>(key);
   if (image_properties_.count(image_key) > 0)
     return image_properties_[image_key];
 
   auto rect_key = static_cast<const WindowProperty<gfx::Rect*>*>(key);
   if (rect_properties_.count(rect_key) > 0)
     return rect_properties_[rect_key];
 
   auto size_key = static_cast<const WindowProperty<gfx::Size*>*>(key);
   if (size_properties_.count(size_key) > 0)
     return size_properties_[size_key];
 
   auto string_key = static_cast<const WindowProperty<std::string*>*>(key);
   if (string_properties_.count(string_key) > 0)
     return string_properties_[string_key];
 
   auto string16_key = static_cast<const WindowProperty<base::string16*>*>(key);
   if (string16_properties_.count(string16_key) > 0)
     return string16_properties_[string16_key];
 
   return std::string();
 }
 
 void PropertyConverter::SetPropertyFromTransportValue(
     Window* window,
     const std::string& transport_name,
     const std::vector<uint8_t>* data) {
   for (const auto& primitive_property : primitive_properties_) {
-    if (primitive_property.second.second == transport_name) {
+    if (primitive_property.second.transport_name == transport_name) {
       // aura::Window only supports property types that fit in PrimitiveType.
       if (data->size() != 8u) {
         DVLOG(2) << "Property size mismatch (PrimitiveType): "
                  << transport_name;
         return;
       }
       const PrimitiveType value = mojo::ConvertTo<PrimitiveType>(*data);
       // TODO(msw): Should aura::Window just store all properties by name?
-      window->SetPropertyInternal(primitive_property.first,
-                                  primitive_property.second.first, nullptr,
-                                  value, 0);
+      window->SetPropertyInternal(
+          primitive_property.first, primitive_property.second.property_name,
+          nullptr, value, primitive_property.second.default_value);
       return;
     }
   }
 
   for (const auto& image_property : image_properties_) {
     if (image_property.second == transport_name) {
       // TODO(msw): Validate the data somehow, before trying to convert?
       // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
       const SkBitmap bitmap = mojo::ConvertTo<SkBitmap>(*data);
       const gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
@@ skipping 50 matching lines @@
 bool PropertyConverter::GetPropertyValueFromTransportValue(
     const std::string& transport_name,
     const std::vector<uint8_t>& transport_data,
     PrimitiveType* value) {
   // aura::Window only supports property types that fit in PrimitiveType.
   if (transport_data.size() != 8u) {
     DVLOG(2) << "Property size mismatch (PrimitiveType): " << transport_name;
     return false;
   }
   for (const auto& primitive_property : primitive_properties_) {
-    if (primitive_property.second.second == transport_name) {
+    if (primitive_property.second.transport_name == transport_name) {
       *value = mojo::ConvertTo<PrimitiveType>(transport_data);
       return true;
     }
   }
   return false;
 }
 
 void PropertyConverter::RegisterProperty(
     const WindowProperty<gfx::ImageSkia*>* property,
     const char* transport_name) {
@@ skipping 17 matching lines @@
     const char* transport_name) {
   string_properties_[property] = transport_name;
 }
 
 void PropertyConverter::RegisterProperty(
     const WindowProperty<base::string16*>* property,
     const char* transport_name) {
   string16_properties_[property] = transport_name;
 }
 
+PropertyConverter::PrimitiveProperty::PrimitiveProperty(
+    const char* property_name,
+    const char* transport_name,
+    const PrimitiveType default_value)
+    : property_name(property_name),
+      transport_name(transport_name),
+      default_value(default_value) {}
+
 }  // namespace aura