Fix auto raw pointer deduction on linux

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 52 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);
+  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);
+  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 size_key = static_cast<const WindowProperty<gfx::Size*>*>(key);
+  auto* size_key = static_cast<const WindowProperty<gfx::Size*>*>(key);
   if (size_properties_.count(size_key) > 0) {
     *transport_value = GetArray(window, size_key);
     return true;
   }
 
-  auto string_key = static_cast<const WindowProperty<std::string*>*>(key);
+  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;
   }
 
-  auto string16_key = static_cast<const WindowProperty<base::string16*>*>(key);
+  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_[key].default_value;
   // TODO(msw): Using the int64_t accessor is wasteful for smaller types.
   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].transport_name;
 
-  auto image_key = static_cast<const WindowProperty<gfx::ImageSkia*>*>(key);
+  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);
+  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);
+  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);
+  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);
+  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) {
@@ skipping 117 matching lines @@
 }
 
 void PropertyConverter::RegisterProperty(
     const WindowProperty<base::string16*>* property,
     const char* transport_name) {
   string16_properties_[property] = transport_name;
   transport_names_.insert(transport_name);
 }
 
 }  // namespace aura