Fix 'auto variable type must not deduce to a raw pointer type' errors in Ozone/Wayland code

ui/ozone/platform/wayland/fake_server.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/ozone/platform/wayland/fake_server.h"
 
 #include <sys/socket.h>
 #include <wayland-server.h>
 #include <xdg-shell-unstable-v5-server-protocol.h>
 
@@ skipping 11 matching lines @@
 const uint32_t kSeatVersion = 4;
 const uint32_t kXdgShellVersion = 1;
 
 void DestroyResource(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 // wl_compositor
 
 void CreateSurface(wl_client* client, wl_resource* resource, uint32_t id) {
-  auto compositor =
+  auto* compositor =
       static_cast<MockCompositor*>(wl_resource_get_user_data(resource));
   wl_resource* surface_resource = wl_resource_create(
       client, &wl_surface_interface, wl_resource_get_version(resource), id);
   if (!surface_resource) {
     wl_client_post_no_memory(client);
     return;
   }
   compositor->AddSurface(base::MakeUnique<MockSurface>(surface_resource));
 }
 
@@ skipping 46 matching lines @@
                         wl_resource* resource,
                         int32_t version) {
   static_cast<MockXdgShell*>(wl_resource_get_user_data(resource))
       ->UseUnstableVersion(version);
 }
 
 void GetXdgSurface(wl_client* client,
                    wl_resource* resource,
                    uint32_t id,
                    wl_resource* surface_resource) {
-  auto surface =
+  auto* surface =
       static_cast<MockSurface*>(wl_resource_get_user_data(surface_resource));
   if (surface->xdg_surface) {
     wl_resource_post_error(resource, XDG_SHELL_ERROR_ROLE,
                            "surface already has a role");
     return;
   }
   wl_resource* xdg_surface_resource = wl_resource_create(
       client, &xdg_surface_interface, wl_resource_get_version(resource), id);
   if (!xdg_surface_resource) {
     wl_client_post_no_memory(client);
@@ skipping 10 matching lines @@
     &DestroyResource,     // destroy
     &UseUnstableVersion,  // use_unstable_version
     &GetXdgSurface,       // get_xdg_surface
     nullptr,              // get_xdg_popup
     &Pong,                // pong
 };
 
 // wl_seat
 
 void GetPointer(wl_client* client, wl_resource* resource, uint32_t id) {
-  auto seat = static_cast<MockSeat*>(wl_resource_get_user_data(resource));
+  auto* seat = static_cast<MockSeat*>(wl_resource_get_user_data(resource));
   wl_resource* pointer_resource = wl_resource_create(
       client, &wl_pointer_interface, wl_resource_get_version(resource), id);
   if (!pointer_resource) {
     wl_client_post_no_memory(client);
     return;
   }
   seat->pointer.reset(new MockPointer(pointer_resource));
 }
 
 void GetKeyboard(wl_client* client, wl_resource* resource, uint32_t id) {
-  auto seat = static_cast<MockSeat*>(wl_resource_get_user_data(resource));
+  auto* seat = static_cast<MockSeat*>(wl_resource_get_user_data(resource));
   wl_resource* keyboard_resource = wl_resource_create(
       client, &wl_keyboard_interface, wl_resource_get_version(resource), id);
   if (!keyboard_resource) {
     wl_client_post_no_memory(client);
     return;
   }
   seat->keyboard.reset(new MockKeyboard(keyboard_resource));
 }
 
 const struct wl_seat_interface seat_impl = {
@@ skipping 69 matching lines @@
 
 ServerObject::ServerObject(wl_resource* resource) : resource_(resource) {}
 
 ServerObject::~ServerObject() {
   if (resource_)
     wl_resource_destroy(resource_);
 }
 
 // static
 void ServerObject::OnResourceDestroyed(wl_resource* resource) {
-  auto obj = static_cast<ServerObject*>(wl_resource_get_user_data(resource));
+  auto* obj = static_cast<ServerObject*>(wl_resource_get_user_data(resource));
   obj->resource_ = nullptr;
 }
 
 MockXdgSurface::MockXdgSurface(wl_resource* resource) : ServerObject(resource) {
   wl_resource_set_implementation(resource, &xdg_surface_impl, this,
                                  &ServerObject::OnResourceDestroyed);
 }
 
 MockXdgSurface::~MockXdgSurface() {}
 
@@ skipping 43 matching lines @@
 bool Global::Initialize(wl_display* display) {
   global_.reset(wl_global_create(display, interface_, version_, this, &Bind));
   return global_ != nullptr;
 }
 
 // static
 void Global::Bind(wl_client* client,
                   void* data,
                   uint32_t version,
                   uint32_t id) {
-  auto global = static_cast<Global*>(data);
+  auto* global = static_cast<Global*>(data);
   wl_resource* resource = wl_resource_create(
       client, global->interface_, std::min(version, global->version_), id);
   if (!resource) {
     wl_client_post_no_memory(client);
     return;
   }
   if (!global->resource_)
     global->resource_ = resource;
   wl_resource_set_implementation(resource, global->implementation_, global,
                                  &Global::OnResourceDestroyed);
   global->OnBind();
 }
 
 // static
 void Global::OnResourceDestroyed(wl_resource* resource) {
-  auto global = static_cast<Global*>(wl_resource_get_user_data(resource));
+  auto* global = static_cast<Global*>(wl_resource_get_user_data(resource));
   if (global->resource_ == resource)
     global->resource_ = nullptr;
 }
 
 MockCompositor::MockCompositor()
     : Global(&wl_compositor_interface, &compositor_impl, kCompositorVersion) {}
 
 MockCompositor::~MockCompositor() {}
 
 void MockCompositor::AddSurface(std::unique_ptr<MockSurface> surface) {
@@ skipping 107 matching lines @@
 }
 
 void FakeServer::OnFileCanReadWithoutBlocking(int fd) {
   wl_event_loop_dispatch(event_loop_, 0);
   wl_display_flush_clients(display_.get());
 }
 
 void FakeServer::OnFileCanWriteWithoutBlocking(int fd) {}
 
 }  // namespace wl