exo: Remove unnecessary wl_*_post_no_memory calls.

components/exo/wayland/server.cc

 // Copyright 2015 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 "components/exo/wayland/server.h"
 
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <wayland-server-core.h>
@@ skipping 89 matching lines @@
 void surface_destroy(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 void surface_attach(wl_client* client,
                     wl_resource* resource,
                     wl_resource* buffer,
                     int32_t x,
                     int32_t y) {
   // TODO(reveman): Implement buffer offset support.
-  if (x || y) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
+  DLOG_IF(WARNING, x || y) << "Unsupported buffer offset: "
+                           << gfx::Point(x, y).ToString();
 
   GetUserDataAs<Surface>(resource)
       ->Attach(buffer ? GetUserDataAs<Buffer>(buffer) : nullptr);
 }
 
 void surface_damage(wl_client* client,
                     wl_resource* resource,
                     int32_t x,
                     int32_t y,
                     int32_t width,
@@ skipping 11 matching lines @@
     wl_client_flush(wl_resource_get_client(resource));
   }
   wl_resource_destroy(resource);
 }
 
 void surface_frame(wl_client* client,
                    wl_resource* resource,
                    uint32_t callback) {
   wl_resource* callback_resource =
       wl_resource_create(client, &wl_callback_interface, 1, callback);
-  if (!callback_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   // base::Unretained is safe as the resource owns the callback.
   scoped_ptr<base::CancelableCallback<void(base::TimeTicks)>>
   cancelable_callback(
       new base::CancelableCallback<void(base::TimeTicks)>(base::Bind(
           &HandleSurfaceFrameCallback, base::Unretained(callback_resource))));
 
   GetUserDataAs<Surface>(resource)
       ->RequestFrameCallback(cancelable_callback->callback());
 
@@ skipping 82 matching lines @@
     region_destroy, region_add, region_subtract};
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_compositor_interface:
 
 void compositor_create_surface(wl_client* client,
                                wl_resource* resource,
                                uint32_t id) {
   scoped_ptr<Surface> surface =
       GetUserDataAs<Display>(resource)->CreateSurface();
-  DCHECK(surface);
 
   wl_resource* surface_resource = wl_resource_create(
       client, &wl_surface_interface, wl_resource_get_version(resource), id);
-  if (!surface_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   // Set the surface resource property for type-checking downcast support.
   surface->SetProperty(kSurfaceResourceKey, surface_resource);
 
   SetImplementation(surface_resource, &surface_implementation,
                     std::move(surface));
 }
 
 void compositor_create_region(wl_client* client,
                               wl_resource* resource,
                               uint32_t id) {
-  scoped_ptr<SkRegion> region(new SkRegion);
-
   wl_resource* region_resource =
       wl_resource_create(client, &wl_region_interface, 1, id);
-  if (!region_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
-  SetImplementation(region_resource, &region_implementation, std::move(region));
+  SetImplementation(region_resource, &region_implementation,
+                    make_scoped_ptr(new SkRegion));
 }
 
 const struct wl_compositor_interface compositor_implementation = {
     compositor_create_surface, compositor_create_region};
 
 const uint32_t compositor_version = 3;
 
 void bind_compositor(wl_client* client,
                      void* data,
                      uint32_t version,
                      uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &wl_compositor_interface,
                          std::min(version, compositor_version), id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
 
   wl_resource_set_implementation(resource, &compositor_implementation, data,
                                  nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_shm_pool_interface:
 
 const struct shm_supported_format {
   uint32_t shm_format;
@@ skipping 35 matching lines @@
       GetUserDataAs<SharedMemory>(resource)
           ->CreateBuffer(gfx::Size(width, height),
                          supported_format->buffer_format, offset, stride);
   if (!buffer) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   wl_resource* buffer_resource =
       wl_resource_create(client, &wl_buffer_interface, 1, id);
-  if (!buffer_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   buffer->set_release_callback(base::Bind(&HandleBufferReleaseCallback,
                                           base::Unretained(buffer_resource)));
 
   SetImplementation(buffer_resource, &buffer_implementation, std::move(buffer));
 }
 
 void shm_pool_destroy(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
@@ skipping 16 matching lines @@
   scoped_ptr<SharedMemory> shared_memory =
       GetUserDataAs<Display>(resource)
           ->CreateSharedMemory(base::FileDescriptor(fd, true), size);
   if (!shared_memory) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   wl_resource* shm_pool_resource =
       wl_resource_create(client, &wl_shm_pool_interface, 1, id);
-  if (!shm_pool_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   SetImplementation(shm_pool_resource, &shm_pool_implementation,
                     std::move(shared_memory));
 }
 
 const struct wl_shm_interface shm_implementation = {shm_create_pool};
 
 void bind_shm(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource = wl_resource_create(client, &wl_shm_interface, 1, id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
 
   wl_resource_set_implementation(resource, &shm_implementation, data, nullptr);
 
   for (const auto& supported_format : shm_supported_formats)
     wl_shm_send_format(resource, supported_format.shm_format);
 }
 
 #if defined(USE_OZONE)
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 71 matching lines @@
       GetUserDataAs<Display>(resource)
           ->CreatePrimeBuffer(base::ScopedFD(name), gfx::Size(width, height),
                               supported_format->buffer_format, stride0);
   if (!buffer) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   wl_resource* buffer_resource =
       wl_resource_create(client, &wl_buffer_interface, 1, id);
-  if (!buffer_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   buffer->set_release_callback(base::Bind(&HandleBufferReleaseCallback,
                                           base::Unretained(buffer_resource)));
 
   SetImplementation(buffer_resource, &buffer_implementation, std::move(buffer));
 }
 
 const struct wl_drm_interface drm_implementation = {
     drm_authenticate, drm_create_buffer, drm_create_planar_buffer,
     drm_create_prime_buffer};
 
 const uint32_t drm_version = 2;
 
 void bind_drm(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource = wl_resource_create(
       client, &wl_drm_interface, std::min(version, drm_version), id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
+
   wl_resource_set_implementation(resource, &drm_implementation, data, nullptr);
 
   if (version >= 2)
     wl_drm_send_capabilities(resource, WL_DRM_CAPABILITY_PRIME);
 
   for (const auto& supported_format : drm_supported_formats)
     wl_drm_send_format(resource, supported_format.drm_format);
 }
 #endif
 
@@ skipping 46 matching lines @@
 
 void subcompositor_get_subsurface(wl_client* client,
                                   wl_resource* resource,
                                   uint32_t id,
                                   wl_resource* surface,
                                   wl_resource* parent) {
   scoped_ptr<SubSurface> subsurface =
       GetUserDataAs<Display>(resource)->CreateSubSurface(
           GetUserDataAs<Surface>(surface), GetUserDataAs<Surface>(parent));
   if (!subsurface) {
-    wl_resource_post_no_memory(resource);
+    wl_resource_post_error(resource, WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
+                           "invalid surface");
     return;
   }
 
   wl_resource* subsurface_resource =
       wl_resource_create(client, &wl_subsurface_interface, 1, id);
-  if (!subsurface_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   SetImplementation(subsurface_resource, &subsurface_implementation,
                     std::move(subsurface));
 }
 
 const struct wl_subcompositor_interface subcompositor_implementation = {
     subcompositor_destroy, subcompositor_get_subsurface};
 
 void bind_subcompositor(wl_client* client,
                         void* data,
                         uint32_t version,
                         uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &wl_subcompositor_interface, 1, id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
+
   wl_resource_set_implementation(resource, &subcompositor_implementation, data,
                                  nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_shell_surface_interface:
 
 void shell_surface_pong(wl_client* client,
                         wl_resource* resource,
                         uint32_t serial) {
@@ skipping 88 matching lines @@
 }
 
 void shell_get_shell_surface(wl_client* client,
                              wl_resource* resource,
                              uint32_t id,
                              wl_resource* surface) {
   scoped_ptr<ShellSurface> shell_surface =
       GetUserDataAs<Display>(resource)
           ->CreateShellSurface(GetUserDataAs<Surface>(surface));
   if (!shell_surface) {
-    wl_resource_post_no_memory(resource);
+    wl_resource_post_error(resource, WL_SHELL_ERROR_ROLE,
+                           "surface has already been assigned a role");
     return;
   }
 
   wl_resource* shell_surface_resource =
       wl_resource_create(client, &wl_shell_surface_interface, 1, id);
-  if (!shell_surface_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   // Shell surfaces are initially disabled and needs to be explicitly mapped
   // before they are enabled and can become visible.
   shell_surface->SetEnabled(false);
 
   shell_surface->set_surface_destroyed_callback(base::Bind(
       &wl_resource_destroy, base::Unretained(shell_surface_resource)));
 
   shell_surface->set_configure_callback(
       base::Bind(&HandleShellSurfaceConfigureCallback,
                  base::Unretained(shell_surface_resource)));
 
   SetImplementation(shell_surface_resource, &shell_surface_implementation,
                     std::move(shell_surface));
 }
 
 const struct wl_shell_interface shell_implementation = {
     shell_get_shell_surface};
 
 void bind_shell(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &wl_shell_interface, 1, id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
+
   wl_resource_set_implementation(resource, &shell_implementation, data,
                                  nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_output_interface:
 
 const uint32_t output_version = 2;
 
 void bind_output(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource = wl_resource_create(
       client, &wl_output_interface, std::min(version, output_version), id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
 
   // TODO(reveman): Watch for display changes and report them.
   // TODO(reveman): Multi-display support.
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   const gfx::Display& primary = display_manager->GetPrimaryDisplayCandidate();
 
   const ash::DisplayInfo& info = display_manager->GetDisplayInfo(primary.id());
   const float kInchInMm = 25.4f;
   const char* kUnknownMake = "unknown";
@@ skipping 184 matching lines @@
 }
 
 void xdg_shell_get_xdg_surface(wl_client* client,
                                wl_resource* resource,
                                uint32_t id,
                                wl_resource* surface) {
   scoped_ptr<ShellSurface> shell_surface =
       GetUserDataAs<Display>(resource)
           ->CreateShellSurface(GetUserDataAs<Surface>(surface));
   if (!shell_surface) {
-    wl_resource_post_no_memory(resource);
+    wl_resource_post_error(resource, XDG_SHELL_ERROR_ROLE,
+                           "surface has already been assigned a role");
     return;
   }
 
   wl_resource* xdg_surface_resource =
       wl_resource_create(client, &xdg_surface_interface, 1, id);
-  if (!xdg_surface_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   shell_surface->set_close_callback(base::Bind(
       &HandleXdgSurfaceCloseCallback, base::Unretained(xdg_surface_resource)));
 
   shell_surface->set_configure_callback(
       base::Bind(&HandleXdgSurfaceConfigureCallback,
                  base::Unretained(xdg_surface_resource)));
 
   SetImplementation(xdg_surface_resource, &xdg_surface_implementation,
                     std::move(shell_surface));
@@ skipping 18 matching lines @@
 const struct xdg_shell_interface xdg_shell_implementation = {
     xdg_shell_destroy, xdg_shell_use_unstable_version,
     xdg_shell_get_xdg_surface, xdg_shell_get_xdg_popup, xdg_shell_pong};
 
 void bind_xdg_shell(wl_client* client,
                     void* data,
                     uint32_t version,
                     uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &xdg_shell_interface, 1, id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
+
   wl_resource_set_implementation(resource, &xdg_shell_implementation, data,
                                  nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_data_device_interface:
 
 void data_device_start_drag(wl_client* client,
                             wl_resource* resource,
                             wl_resource* source_resource,
@@ skipping 21 matching lines @@
                                             uint32_t id) {
   NOTIMPLEMENTED();
 }
 
 void data_device_manager_get_data_device(wl_client* client,
                                          wl_resource* resource,
                                          uint32_t id,
                                          wl_resource* seat_resource) {
   wl_resource* data_device_resource =
       wl_resource_create(client, &wl_data_device_interface, 1, id);
-  if (!data_device_resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
 
   wl_resource_set_implementation(data_device_resource,
                                  &data_device_implementation, nullptr, nullptr);
 }
 
 const struct wl_data_device_manager_interface
     data_device_manager_implementation = {
         data_device_manager_create_data_source,
         data_device_manager_get_data_device};
 
 void bind_data_device_manager(wl_client* client,
                               void* data,
                               uint32_t version,
                               uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &wl_data_device_manager_interface, 1, id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
 
   wl_resource_set_implementation(resource, &data_device_manager_implementation,
                                  data, nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_pointer_interface:
 
 // Pointer delegate class that accepts events for surfaces owned by the same
 // client as a pointer resource.
@@ skipping 336 matching lines @@
 }
 
 const struct wl_touch_interface touch_implementation = {touch_release};
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_seat_interface:
 
 void seat_get_pointer(wl_client* client, wl_resource* resource, uint32_t id) {
   wl_resource* pointer_resource = wl_resource_create(
       client, &wl_pointer_interface, wl_resource_get_version(resource), id);
-  if (!pointer_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   SetImplementation(pointer_resource, &pointer_implementation,
                     make_scoped_ptr(new Pointer(
                         new WaylandPointerDelegate(pointer_resource))));
 }
 
 void seat_get_keyboard(wl_client* client, wl_resource* resource, uint32_t id) {
 #if defined(USE_XKBCOMMON)
   uint32_t version = wl_resource_get_version(resource);
   wl_resource* keyboard_resource =
       wl_resource_create(client, &wl_keyboard_interface, version, id);
-  if (!keyboard_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   SetImplementation(keyboard_resource, &keyboard_implementation,
                     make_scoped_ptr(new Keyboard(
                         new WaylandKeyboardDelegate(keyboard_resource))));
 
   // TODO(reveman): Keep repeat info synchronized with chromium and the host OS.
   if (version >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
     wl_keyboard_send_repeat_info(keyboard_resource, 40, 500);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 void seat_get_touch(wl_client* client, wl_resource* resource, uint32_t id) {
   wl_resource* touch_resource = wl_resource_create(
       client, &wl_touch_interface, wl_resource_get_version(resource), id);
-  if (!touch_resource) {
-    wl_resource_post_no_memory(resource);
-    return;
-  }
 
   SetImplementation(
       touch_resource, &touch_implementation,
       make_scoped_ptr(new Touch(new WaylandTouchDelegate(touch_resource))));
 }
 
 const struct wl_seat_interface seat_implementation = {
     seat_get_pointer, seat_get_keyboard, seat_get_touch};
 
 const uint32_t seat_version = 4;
 
 void bind_seat(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource = wl_resource_create(
       client, &wl_seat_interface, std::min(version, seat_version), id);
-  if (!resource) {
-    wl_client_post_no_memory(client);
-    return;
-  }
 
   wl_resource_set_implementation(resource, &seat_implementation, data, nullptr);
 
   if (version >= WL_SEAT_NAME_SINCE_VERSION)
     wl_seat_send_name(resource, "default");
 
   uint32_t capabilities = WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_TOUCH;
 #if defined(USE_XKBCOMMON)
   capabilities |= WL_SEAT_CAPABILITY_KEYBOARD;
 #endif
@@ skipping 54 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo