Add gfx::ImageSkia and icon support to aura::PropertyConverter.

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 "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"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 36 matching lines @@
 
 bool PropertyConverter::ConvertPropertyForTransport(
     Window* window,
     const void* key,
     std::string* transport_name,
     std::unique_ptr<std::vector<uint8_t>>* transport_value) {
   *transport_name = GetTransportNameForPropertyKey(key);
   if (transport_name->empty())
     return false;
 
+  auto image_key = static_cast<const WindowProperty<gfx::ImageSkia*>*>(key);
+  if (image_properties_.count(image_key) > 0) {
+    const gfx::ImageSkia* value = window->GetProperty(image_key);
+    if (value) {
+      // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
+      SkBitmap bitmap = value->GetRepresentation(1.f).sk_bitmap();
+      *transport_value = base::MakeUnique<std::vector<uint8_t>>(
+          mojo::ConvertTo<std::vector<uint8_t>>(bitmap));
+    } else {
+      *transport_value = base::MakeUnique<std::vector<uint8_t>>();
+    }
+    return true;
+  }
+
   auto rect_key = static_cast<const WindowProperty<gfx::Rect*>*>(key);
   if (rect_properties_.count(rect_key) > 0) {
     *transport_value = GetArray(window, rect_key);
     return true;
   }
 
   auto string_key = static_cast<const WindowProperty<std::string*>*>(key);
   if (string_properties_.count(string_key) > 0) {
     *transport_value = GetArray(window, string_key);
     return true;
@@ skipping 11 matching lines @@
   const int64_t value = window->GetPropertyInternal(key, 0);
   *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;
 
+  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 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)
@@ skipping 15 matching lines @@
       }
       const int64_t value = mojo::ConvertTo<int64_t>(*data);
       // TODO(msw): Should aura::Window just store all properties by name?
       window->SetPropertyInternal(primitive_property.first,
                                   primitive_property.second.first, nullptr,
                                   value, 0);
       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);
+      window->SetProperty(image_property.first, new gfx::ImageSkia(image));
+      return;
+    }
+  }
+
   for (const auto& rect_property : rect_properties_) {
     if (rect_property.second == transport_name) {
       if (data->size() != 16u) {
         DVLOG(2) << "Property size mismatch (gfx::Rect): " << transport_name;
         return;
       }
       const gfx::Rect value = mojo::ConvertTo<gfx::Rect>(*data);
       window->SetProperty(rect_property.first, new gfx::Rect(value));
       return;
     }
@@ skipping 14 matching lines @@
       const base::string16 value = mojo::ConvertTo<base::string16>(*data);
       window->SetProperty(string16_property.first, new base::string16(value));
       return;
     }
   }
 
   DVLOG(2) << "Unknown mus property name: " << transport_name;
 }
 
 void PropertyConverter::RegisterProperty(
+    const WindowProperty<gfx::ImageSkia*>* property,
+    const char* transport_name) {
+  image_properties_[property] = transport_name;
+}
+
+void PropertyConverter::RegisterProperty(
     const WindowProperty<gfx::Rect*>* property,
     const char* transport_name) {
   rect_properties_[property] = transport_name;
 }
 
 void PropertyConverter::RegisterProperty(
     const WindowProperty<std::string*>* property,
     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;
 }
 
 }  // namespace aura