wayland: free framebuffer's shell surface on destroy

This prevents leaking the Wayland shell surface associated with a Cogl
OnScreen when it is finalised.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit 760fc9f3af5475530262b82a55df311fceca358a)
cogland: Correctly handle commits without attaching a new buffer

Previously if a client sent a commit message without attaching a new
buffer then it would end up detaching the existing buffer because
surface->pending.buffer would be NULL. This patch makes it explicitly
track when an attach is sent for a commit and so that it can avoid
making any changes otherwise. This fixes cases where GTK apps would
send a damage event without a new buffer.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit aa412b9c709120bd8d88a014010c448f3b9fcfb7)
cogland: Embed the wl_surface struct directly into CoglandSurface

The wl_surface struct has been removed from libwayland-server so
instead we can just embed its only memeber, the resource, directly
into CoglandSurface.

http://cgit.freedesktop.org/wayland/wayland/commit/?id=508dd69b5654

https://bugzilla.gnome.org/show_bug.cgi?id=700088

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit 15c58ce03ce97df659dade0e10be7807eb7b2296)
cogland: Listen for Expose events when Cogl is using X

Since 906e1b5eb535a86 Cogland no longer redraws constantly but instead
only draws once at startup and then again whenever a client attaches a
new buffer. Sometimes however it seems that the first paint will get
lost perhaps because it is sent before the window is fully mapped. As
it was previously not handling expose events it would not paint again
until the first client is connected so there would be a blank window
which looks broken.

This patch makes it handle Expose events when it detects that Cogl is
using an X backend. On other backends it will resort to queuing a
redraw every 16ms as it did before.

Although this is probably a bit overkill for such a small example, it
seems like a good idea to only redraw when we think it's necessary so
that we can be sure that the mechanism works. Handling the expose
events means we can have at least one platform where we can test this.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit 99cf15b285302243395873d78f05a5895c173eef)
Add test that Cogl doesn't crash when freeing unallocated texture

It looks like Cogl doesn't currently clean up an unallocated atlas
texture properly so if it fails to allocate it. It will then crash
when it is freed. This adds a conformance test to verify that all of
the various texture types can be freed without allocating them.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit bfada22d9a7f60baad5ae5615e45f10327e23e36)

Conflicts:
	tests/conform/test-conform-main.c
Fix freeing an atlas texture that hasn't been allocated

The free function for atlas textures was previously always assuming
that there will be a valid sub_texture pointer but this might not be
the case if the texture was never successfully allocated. This was
causing Cogl to crash if the application tries to make a texture that
can not fit in the atlas using the automagic texture API.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit a7a8b7aefc8cb03fe8b716bee06b3449a7dba85f)

Conflicts:
	tests/conform/test-conform-main.c
Don't handle the out-of-memory error specially for auto-textures

Previously when trying the three different texture types to create an
automagic texture it would handle the out-of-memory error specially
and bypass trying the remaining texture types. Presumably the idea is
that out-of-memory is a serious error and it can't be recovered from.
However, in the case of atlas textures, this error will be thrown if
the texture is too large to fit into an atlas. In that case it makes
sense to try another texture type so that it can fallback to using a
sliced texture. I think conceptually each different texture type will
have different memory requirements so it seems reasonable to try the
others if there is not enough memory for one of them.

This was causing cogl_texture_new_from_data to break when loading very
large textures because it wouldn't end up slicing them.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

(cherry picked from commit ad6968135a01823eb6a94668dd22c7a4df6f9327)
cogl-fixed: Don't use inline ARM assembler when building for Thumb

There are two asm() statements in cogl-fixed.c that can't be assembled
in Thumb mode. This patch switches it to the generic code in Thumb
mode.

Signed-off-by: Donn Seeley <donn.seeley@windriver.com>
Reviewed-by: Neil Roberts <neil@linux.intel.com>

(cherry picked from commit 839cf49763cfe28f58b9e1ddb6282d8fbbe7a381)
cogl-fixed: In ARM asm don't allow GCC to reuse input regs for outputs

Add register constraints to prevent asm statement complaints like:

  {standard input}:382: rdhi, rdlo and rm must all be different

Signed-off-by: Donn Seeley <donn.seeley@windriver.com>
Reviewed-by: Neil Roberts <neil@linux.intel.com>

(cherry picked from commit b32d135299a32d6a5594279fcdfa5a0b51c9c1ee)