Mac Overlays: Plumb through GL solid color overlay support

content/common/gpu/image_transport_surface_overlay_mac.mm

 // 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 "content/common/gpu/image_transport_surface_overlay_mac.h"
 
 #include <algorithm>
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLTypes.h>
@@ skipping 79 matching lines @@
  public:
   OverlayPlane(int z_order,
                base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                const gfx::RectF& dip_frame_rect,
                const gfx::RectF& contents_rect)
       : z_order(z_order),
         io_surface(io_surface),
         dip_frame_rect(dip_frame_rect),
         contents_rect(contents_rect),
         layer_needs_update(true) {}
+
+  OverlayPlane(int z_order,
+               const gfx::RectF& dip_frame_rect,
+               float red, float green, float blue, float alpha)
+      : z_order(z_order),
+        solid_color(CGColorCreateGenericRGB(red, green, blue, alpha)),
+        dip_frame_rect(dip_frame_rect),
+        layer_needs_update(true) {}
+
   ~OverlayPlane() { DCHECK(!ca_layer); }
 
   const int z_order;
   base::scoped_nsobject<CALayer> ca_layer;
 
   // The IOSurface to set the CALayer's contents to.
   const base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
+  base::ScopedCFTypeRef<CGColorRef> solid_color;
   const gfx::RectF dip_frame_rect;
   const gfx::RectF contents_rect;
 
   bool layer_needs_update;
 
   static bool Compare(const linked_ptr<OverlayPlane>& a,
                       const linked_ptr<OverlayPlane>& b) {
     return (a->z_order < b->z_order);
   }
 
   void TakeCALayerFrom(OverlayPlane* other_plane) {
     ca_layer.swap(other_plane->ca_layer);
   }
 
   void UpdateProperties() {
     if (layer_needs_update) {
       [ca_layer setOpaque:YES];
       [ca_layer setFrame:dip_frame_rect.ToCGRect()];
       [ca_layer setContentsRect:contents_rect.ToCGRect()];
-      id new_contents = static_cast<id>(io_surface.get());
-      if ([ca_layer contents] == new_contents && z_order == 0) {
-        [ca_layer setContentsChanged];
-      } else {
-        [ca_layer setContents:new_contents];
+      if (io_surface.get()) {
+        id new_contents = static_cast<id>(io_surface.get());
+        if ([ca_layer contents] == new_contents && z_order == 0) {
+          [ca_layer setContentsChanged];
+        } else {
+          [ca_layer setContents:new_contents];
+        }
+      }
+      if (solid_color.get()) {
+        [ca_layer setBackgroundColor:solid_color];
       }
     }
     static bool show_borders =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kShowMacOverlayBorders);
     if (show_borders) {
       base::ScopedCFTypeRef<CGColorRef> color;
       if (!layer_needs_update) {
         // Green represents contents that are unchanged across frames.
         color.reset(CGColorCreateGenericRGB(0, 1, 0, 1));
@@ skipping 497 matching lines @@
                        ConvertRectToDIPF(scale_factor_, bounds_rect),
                        crop_rect));
   if (z_order == 0)
     pending_root_plane_ = plane;
   else
     pending_overlay_planes_.push_back(plane);
 
   return true;
 }
 
+bool ImageTransportSurfaceOverlayMac::ScheduleSolidColorOverlayPlane(
+    int z_order,
+    const gfx::Rect& bounds_rect,
+    float red,
+    float green,
+    float blue,
+    float alpha) {
+  linked_ptr<OverlayPlane> plane(
+      new OverlayPlane(z_order,
+                       ConvertRectToDIPF(scale_factor_, bounds_rect),
+                       red, green, blue, alpha));
+  pending_overlay_planes_.push_back(plane);
+  return true;
+}
+
 bool ImageTransportSurfaceOverlayMac::IsSurfaceless() const {
   return true;
 }
 
 void ImageTransportSurfaceOverlayMac::OnBufferPresented(
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   vsync_timebase_ = params.vsync_timebase;
   vsync_interval_ = params.vsync_interval;
   vsync_parameters_valid_ = (vsync_interval_ != base::TimeDelta());
 
@@ skipping 49 matching lines @@
   // Compute the previous vsync time.
   base::TimeTicks previous_vsync =
       vsync_interval_ * ((from - vsync_timebase_) / vsync_interval_) +
       vsync_timebase_;
 
   // Return |interval_fraction| through the next vsync.
   return previous_vsync + (1 + interval_fraction) * vsync_interval_;
 }
 
 }  // namespace content