Mac Overlays: Wire up overlays on Mac

ui/gl/gl_image_io_surface.mm

 // Copyright 2013 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/gl/gl_image_io_surface.h"
 
+#include "base/mac/foundation_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 
 // Note that this must be included after gl_bindings.h to avoid conflicts.
+#include <Quartz/Quartz.h>
 #include <OpenGL/CGLIOSurface.h>
 
 namespace gfx {
 namespace {
 
 bool ValidInternalFormat(unsigned internalformat) {
   switch (internalformat) {
     case GL_R8:
     case GL_BGRA_EXT:
       return true;
@@ skipping 164 matching lines @@
                                        const Point& offset,
                                        const Rect& rect) {
   return false;
 }
 
 bool GLImageIOSurface::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                             int z_order,
                                             OverlayTransform transform,
                                             const Rect& bounds_rect,
                                             const RectF& crop_rect) {
-  return false;
+  // Only simple overlay planes are currently supported.
+  DCHECK_EQ(z_order, 0);
+  DCHECK_EQ(crop_rect.ToString(), gfx::RectF(0, 0, 1, 1).ToString());
+  DCHECK_EQ(transform, gfx::OVERLAY_TRANSFORM_NONE);
+
+  // Note that gfx::AcceleratedWidget does not actually map to CALayer in this
+  // context. It may be that the types should coincide.
+  CALayer* layer = base::mac::ObjCCastStrict<CALayer>(widget);

[alexst (slow to review), 2015/07/22 14:38:02]

In the type definitions 

#elif defined(OS_MACOSX)
typedef NSView* AcceleratedWidget;
...

If I understand correctly, you are using the widget as a transport type to pass
the layer into the image. Are CALayer and NSView related? Is it safe to cast
them around like that?

The way we use it on ozone and the way I thought of it conceptually is that you
are presenting the contents of an image as an overlay for the compositor whose
backing surface is represented by |widget|. If the types (per above) are
compatible and CALayer looks like it is indeed a form of backing surface, I
think this is fine. Otherwise, maybe you could just have a maps of widget ->
layer to resolve type safety.

[ccameron, 2015/07/23 05:33:02]

I'm not sure if we actually use NSView as a type anywhere. In the browser
process, we use a phony NSView* and a map to internal structures here:
https://code.google.com/p/chromium/codesearch#chromium/src/ui/accelerated_wid...

As it is, I'm essentially treating it as a void*, with some casts.

+
+  // Also note that transactions are not disabled. The caller must ensure that
+  // all changes to the CALayer tree happen atomically.
+  [layer setContents:(id)io_surface_.get()];
+  [layer setFrame:bounds_rect.ToCGRect()];
+  return true;
 }
 
 }  // namespace gfx