Fix accelerated_widget_mac compile

ui/accelerated_widget_mac/ca_layer_tree_unittest_mac.mm

 // 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 <AVFoundation/AVFoundation.h>
 #include <memory>
 
 #include "base/mac/sdk_forward_declarations.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accelerated_widget_mac/ca_renderer_layer_tree.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/mac/io_surface.h"
+#include "ui/gl/ca_renderer_layer_params.h"
+#include "ui/gl/gl_image_io_surface.h"
 
 namespace gpu {
 
 namespace {
 
 struct CALayerProperties {
+  CALayerProperties() {}
+  ~CALayerProperties() {
+    if (gl_image)
+      gl_image->Destroy(true);
+  }
+
   bool is_clipped = true;
   gfx::Rect clip_rect;
   int sorting_context_id = 0;
   gfx::Transform transform;
   gfx::RectF contents_rect = gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f);
   gfx::Rect rect = gfx::Rect(0, 0, 256, 256);
   unsigned background_color = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
   unsigned edge_aa_mask = 0;
   float opacity = 1.0f;
   float scale_factor = 1.0f;
   unsigned filter = GL_LINEAR;
-  base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
-  base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
+  scoped_refptr<gl::GLImageIOSurface> gl_image;
 };
 
+scoped_refptr<gl::GLImageIOSurface> CreateGLImage(const gfx::Size& size,
+                                                  gfx::BufferFormat format,
+                                                  bool video) {
+  scoped_refptr<gl::GLImageIOSurface> gl_image(
+      new gl::GLImageIOSurface(size, GL_RGBA));
+  base::ScopedCFTypeRef<IOSurfaceRef> io_surface(
+      gfx::CreateIOSurface(size, format));
+  if (video) {
+    base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
+    CVPixelBufferCreateWithIOSurface(nullptr, io_surface, nullptr,
+                                     cv_pixel_buffer.InitializeInto());
+    gl_image->InitializeWithCVPixelBuffer(cv_pixel_buffer,
+                                          gfx::GenericSharedMemoryId(), format);
+  } else {
+    gl_image->Initialize(io_surface, gfx::GenericSharedMemoryId(), format);
+  }
+  return gl_image;
+}
+
 bool ScheduleCALayer(ui::CARendererLayerTree* tree,
                      CALayerProperties* properties) {
-  return tree->ScheduleCALayer(
+  return tree->ScheduleCALayer(ui::CARendererLayerParams(
       properties->is_clipped, properties->clip_rect,
       properties->sorting_context_id, properties->transform,
-      properties->io_surface, properties->cv_pixel_buffer,
-      properties->contents_rect, properties->rect, properties->background_color,
-      properties->edge_aa_mask, properties->opacity, properties->filter);
+      properties->gl_image.get(), properties->contents_rect, properties->rect,
+      properties->background_color, properties->edge_aa_mask,
+      properties->opacity, properties->filter));
 }
 
 void UpdateCALayerTree(std::unique_ptr<ui::CARendererLayerTree>& ca_layer_tree,
                        CALayerProperties* properties,
                        CALayer* superlayer) {
   std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
       new ui::CARendererLayerTree);
   bool result = ScheduleCALayer(new_ca_layer_tree.get(), properties);
   EXPECT_TRUE(result);
   new_ca_layer_tree->CommitScheduledCALayers(
@@ skipping 18 matching lines @@
 // Test updating each layer's properties.
 TEST_F(CALayerTreeTest, PropertyUpdates) {
   CALayerProperties properties;
   properties.clip_rect = gfx::Rect(2, 4, 8, 16);
   properties.transform.Translate(10, 20);
   properties.contents_rect = gfx::RectF(0.0f, 0.25f, 0.5f, 0.75f);
   properties.rect = gfx::Rect(16, 32, 64, 128);
   properties.background_color = SkColorSetARGB(0xFF, 0xFF, 0, 0);
   properties.edge_aa_mask = GL_CA_LAYER_EDGE_LEFT_CHROMIUM;
   properties.opacity = 0.5f;
-  properties.io_surface.reset(
-      gfx::CreateIOSurface(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888));
+  properties.gl_image =
+      CreateGLImage(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888, false);
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree;
   CALayer* root_layer = nil;
   CALayer* clip_and_sorting_layer = nil;
   CALayer* transform_layer = nil;
   CALayer* content_layer = nil;
 
   // Validate the initial values.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
@@ skipping 22 matching lines @@
     EXPECT_EQ(-properties.clip_rect.origin().y(),
               [clip_and_sorting_layer sublayerTransform].m42);
 
     // Validate the transform layer.
     EXPECT_EQ(properties.transform.matrix().get(3, 0),
               [transform_layer sublayerTransform].m41);
     EXPECT_EQ(properties.transform.matrix().get(3, 1),
               [transform_layer sublayerTransform].m42);
 
     // Validate the content layer.
-    EXPECT_EQ(static_cast<id>(properties.io_surface.get()),
+    EXPECT_EQ(static_cast<id>(properties.gl_image->io_surface().get()),
               [content_layer contents]);
     EXPECT_EQ(properties.contents_rect,
               gfx::RectF([content_layer contentsRect]));
     EXPECT_EQ(properties.rect.origin(), gfx::Point([content_layer position]));
     EXPECT_EQ(gfx::Rect(properties.rect.size()),
               gfx::Rect([content_layer bounds]));
     EXPECT_EQ(kCALayerLeftEdge, [content_layer edgeAntialiasingMask]);
     EXPECT_EQ(properties.opacity, [content_layer opacity]);
     EXPECT_NSEQ(kCAFilterLinear, [content_layer minificationFilter]);
     EXPECT_NSEQ(kCAFilterLinear, [content_layer magnificationFilter]);
@@ skipping 86 matching lines @@
               [[clip_and_sorting_layer sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
     EXPECT_EQ(content_layer, [[transform_layer sublayers] objectAtIndex:0]);
 
     // Validate the content layer. Note that top and bottom edges flip.
     EXPECT_EQ(kCALayerBottomEdge, [content_layer edgeAntialiasingMask]);
   }
 
   // Change the contents and commit.
   {
-    properties.io_surface.reset();
+    properties.gl_image->Destroy(true);
+    properties.gl_image = nullptr;
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     EXPECT_EQ(transform_layer,
               [[clip_and_sorting_layer sublayers] objectAtIndex:0]);
@@ skipping 86 matching lines @@
     EXPECT_EQ(content_layer, [[transform_layer sublayers] objectAtIndex:0]);
 
     // Validate the content layer.
     EXPECT_NSEQ(kCAFilterNearest, [content_layer minificationFilter]);
     EXPECT_NSEQ(kCAFilterNearest, [content_layer magnificationFilter]);
   }
 
   // Add the clipping and IOSurface contents back.
   {
     properties.is_clipped = true;
-    properties.io_surface.reset(
-        gfx::CreateIOSurface(gfx::Size(256, 256),
-                             gfx::BufferFormat::BGRA_8888));
+    properties.gl_image =
+        CreateGLImage(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888, false);
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     EXPECT_EQ(transform_layer,
               [[clip_and_sorting_layer sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
     EXPECT_EQ(content_layer, [[transform_layer sublayers] objectAtIndex:0]);
 
     // Validate the content layer.
-    EXPECT_EQ(static_cast<id>(properties.io_surface.get()),
+    EXPECT_EQ(static_cast<id>(properties.gl_image->io_surface().get()),
               [content_layer contents]);
     EXPECT_EQ(kCALayerBottomEdge, [content_layer edgeAntialiasingMask]);
   }
 
   // Change the scale factor. This should result in a new tree being created.
   {
     properties.scale_factor = 2.0f;
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
@@ skipping 24 matching lines @@
     EXPECT_EQ(-properties.clip_rect.origin().y() / properties.scale_factor,
               [clip_and_sorting_layer sublayerTransform].m42);
 
     // Validate the transform layer.
     EXPECT_EQ(properties.transform.matrix().get(3, 0) / properties.scale_factor,
               [transform_layer sublayerTransform].m41);
     EXPECT_EQ(properties.transform.matrix().get(3, 1) / properties.scale_factor,
               [transform_layer sublayerTransform].m42);
 
     // Validate the content layer.
-    EXPECT_EQ(static_cast<id>(properties.io_surface.get()),
+    EXPECT_EQ(static_cast<id>(properties.gl_image->io_surface().get()),
               [content_layer contents]);
     EXPECT_EQ(properties.contents_rect,
               gfx::RectF([content_layer contentsRect]));
     EXPECT_EQ(gfx::ConvertPointToDIP(properties.scale_factor,
                                      properties.rect.origin()),
               gfx::Point([content_layer position]));
     EXPECT_EQ(gfx::ConvertRectToDIP(properties.scale_factor,
                                     gfx::Rect(properties.rect.size())),
               gfx::Rect([content_layer bounds]));
     EXPECT_EQ(kCALayerBottomEdge, [content_layer edgeAntialiasingMask]);
     EXPECT_EQ(properties.opacity, [content_layer opacity]);
     if ([content_layer respondsToSelector:(@selector(contentsScale))])
       EXPECT_EQ(properties.scale_factor, [content_layer contentsScale]);
   }
+
+  properties.gl_image->Destroy(true);
 }
 
 // Verify that sorting context zero is split at non-flat transforms.
 TEST_F(CALayerTreeTest, SplitSortingContextZero) {
   CALayerProperties properties;
   properties.is_clipped = false;
   properties.clip_rect = gfx::Rect();
   properties.rect = gfx::Rect(0, 0, 256, 256);
 
   // We'll use the IOSurface contents to identify the content layers.
-  base::ScopedCFTypeRef<IOSurfaceRef> io_surfaces[5];
+  scoped_refptr<gl::GLImageIOSurface> gl_images[5];
   for (size_t i = 0; i < 5; ++i) {
-    io_surfaces[i].reset(gfx::CreateIOSurface(
-        gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888));
+    gl_images[i] =
+        CreateGLImage(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888, false);
   }
 
   // Have 5 transforms:
   // * 2 flat but different (1 sorting context layer, 2 transform layers)
   // * 1 non-flat (new sorting context layer)
   // * 2 flat and the same (new sorting context layer, 1 transform layer)
   gfx::Transform transforms[5];
   transforms[0].Translate(10, 10);
   transforms[1].RotateAboutZAxis(45.0f);
   transforms[2].RotateAboutYAxis(45.0f);
   transforms[3].Translate(10, 10);
   transforms[4].Translate(10, 10);
 
   // Schedule and commit the layers.
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree(
       new ui::CARendererLayerTree);
   for (size_t i = 0; i < 5; ++i) {
-    properties.io_surface = io_surfaces[i];
+    properties.gl_image = gl_images[i];
     properties.transform = transforms[i];
     bool result = ScheduleCALayer(ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
   }
   ca_layer_tree->CommitScheduledCALayers(superlayer_, nullptr,
                                          properties.scale_factor);
 
   // Validate the root layer.
   EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
   CALayer* root_layer = [[superlayer_ sublayers] objectAtIndex:0];
@@ skipping 27 matching lines @@
   // Validate that the third sorting context has 1 transform layer with two
   // content layers.
   EXPECT_EQ(1u, [[clip_and_sorting_layer_2 sublayers] count]);
   CALayer* transform_layer_2_0 =
       [[clip_and_sorting_layer_2 sublayers] objectAtIndex:0];
   EXPECT_EQ(2u, [[transform_layer_2_0 sublayers] count]);
   CALayer* content_layer_3 = [[transform_layer_2_0 sublayers] objectAtIndex:0];
   CALayer* content_layer_4 = [[transform_layer_2_0 sublayers] objectAtIndex:1];
 
   // Validate that the layers come out in order.
-  EXPECT_EQ(static_cast<id>(io_surfaces[0].get()), [content_layer_0 contents]);
-  EXPECT_EQ(static_cast<id>(io_surfaces[1].get()), [content_layer_1 contents]);
-  EXPECT_EQ(static_cast<id>(io_surfaces[2].get()), [content_layer_2 contents]);
-  EXPECT_EQ(static_cast<id>(io_surfaces[3].get()), [content_layer_3 contents]);
-  EXPECT_EQ(static_cast<id>(io_surfaces[4].get()), [content_layer_4 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[0]->io_surface().get()),
+            [content_layer_0 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[1]->io_surface().get()),
+            [content_layer_1 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[2]->io_surface().get()),
+            [content_layer_2 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[3]->io_surface().get()),
+            [content_layer_3 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[4]->io_surface().get()),
+            [content_layer_4 contents]);
+
+  for (size_t i = 0; i < 5; ++i)
+    gl_images[i]->Destroy(true);
 }
 
 // Verify that sorting contexts are allocated appropriately.
 TEST_F(CALayerTreeTest, SortingContexts) {
   CALayerProperties properties;
   properties.is_clipped = false;
   properties.clip_rect = gfx::Rect();
   properties.rect = gfx::Rect(0, 0, 256, 256);
 
   // We'll use the IOSurface contents to identify the content layers.
-  base::ScopedCFTypeRef<IOSurfaceRef> io_surfaces[3];
+  scoped_refptr<gl::GLImageIOSurface> gl_images[3];
   for (size_t i = 0; i < 3; ++i) {
-    io_surfaces[i].reset(gfx::CreateIOSurface(
-        gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888));
+    gl_images[i] =
+        CreateGLImage(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888, false);
   }
 
   int sorting_context_ids[3] = {3, -1, 0};
 
   // Schedule and commit the layers.
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree(
       new ui::CARendererLayerTree);
   for (size_t i = 0; i < 3; ++i) {
     properties.sorting_context_id = sorting_context_ids[i];
-    properties.io_surface = io_surfaces[i];
+    properties.gl_image = gl_images[i];
     bool result = ScheduleCALayer(ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
   }
   ca_layer_tree->CommitScheduledCALayers(superlayer_, nullptr,
                                          properties.scale_factor);
 
   // Validate the root layer.
   EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
   CALayer* root_layer = [[superlayer_ sublayers] objectAtIndex:0];
 
@@ skipping 16 matching lines @@
 
   // Validate that each transform has 1 content layer.
   EXPECT_EQ(1u, [[transform_layer_0 sublayers] count]);
   CALayer* content_layer_0 = [[transform_layer_0 sublayers] objectAtIndex:0];
   EXPECT_EQ(1u, [[transform_layer_1 sublayers] count]);
   CALayer* content_layer_1 = [[transform_layer_1 sublayers] objectAtIndex:0];
   EXPECT_EQ(1u, [[transform_layer_2 sublayers] count]);
   CALayer* content_layer_2 = [[transform_layer_2 sublayers] objectAtIndex:0];
 
   // Validate that the layers come out in order.
-  EXPECT_EQ(static_cast<id>(io_surfaces[0].get()), [content_layer_0 contents]);
-  EXPECT_EQ(static_cast<id>(io_surfaces[1].get()), [content_layer_1 contents]);
-  EXPECT_EQ(static_cast<id>(io_surfaces[2].get()), [content_layer_2 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[0]->io_surface().get()),
+            [content_layer_0 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[1]->io_surface().get()),
+            [content_layer_1 contents]);
+  EXPECT_EQ(static_cast<id>(gl_images[2]->io_surface().get()),
+            [content_layer_2 contents]);
+
+  for (size_t i = 0; i < 3; ++i)
+    gl_images[i]->Destroy(true);
 }
 
 // Verify that sorting contexts must all have the same clipping properties.
 TEST_F(CALayerTreeTest, SortingContextMustHaveConsistentClip) {
   CALayerProperties properties;
 
   // Vary the clipping parameters within sorting contexts.
   bool is_clippeds[3] = { true, true, false};
   gfx::Rect clip_rects[3] = {
       gfx::Rect(0, 0, 16, 16),
@@ skipping 32 matching lines @@
     properties.clip_rect = clip_rects[0];
 
     bool result = ScheduleCALayer(ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
   }
 }
 
 // Test updating each layer's properties.
 TEST_F(CALayerTreeTest, AVLayer) {
   CALayerProperties properties;
-  properties.io_surface.reset(gfx::CreateIOSurface(
-      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR));
+  properties.gl_image =
+      CreateGLImage(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888, false);
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree;
   CALayer* root_layer = nil;
   CALayer* clip_and_sorting_layer = nil;
   CALayer* transform_layer = nil;
   CALayer* content_layer1 = nil;
   CALayer* content_layer2 = nil;
   CALayer* content_layer3 = nil;
+  CALayer* content_layer4 = nil;
 
   // Validate the initial values.
   {
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     transform_layer = [[clip_and_sorting_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
     content_layer1 = [[transform_layer sublayers] objectAtIndex:0];
 
     // Validate the content layer.
     EXPECT_FALSE([content_layer1
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
   }
 
-  properties.io_surface.reset(gfx::CreateIOSurface(
-      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR));
+  properties.gl_image->Destroy(true);
+  properties.gl_image = CreateGLImage(
+      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR, false);
 
-  // Pass another frame.
+  // Pass another frame. This will automatically create a CVPixelBuffer
+  // behind the scenes, because the underlying buffer is YUV 420.
   {
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     transform_layer = [[clip_and_sorting_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
     content_layer2 = [[transform_layer sublayers] objectAtIndex:0];
 
     // Validate the content layer.
-    EXPECT_FALSE([content_layer2
+    EXPECT_TRUE([content_layer2
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
-    EXPECT_EQ(content_layer2, content_layer1);
+    EXPECT_NE(content_layer2, content_layer1);
   }
 
-  properties.io_surface.reset(gfx::CreateIOSurface(
-      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR));
-  CVPixelBufferCreateWithIOSurface(nullptr, properties.io_surface, nullptr,
-                                   properties.cv_pixel_buffer.InitializeInto());
+  properties.gl_image->Destroy(true);
+  properties.gl_image = CreateGLImage(
+      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR, true);
 
-  // Pass a frame with a CVPixelBuffer
+  // Pass a frame with a CVPixelBuffer.
   {
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     transform_layer = [[clip_and_sorting_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
-    content_layer2 = [[transform_layer sublayers] objectAtIndex:0];
+    content_layer3 = [[transform_layer sublayers] objectAtIndex:0];
 
     // Validate the content layer.
-    EXPECT_TRUE([content_layer2
+    EXPECT_TRUE([content_layer3
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
-    EXPECT_NE(content_layer2, content_layer1);
+    EXPECT_EQ(content_layer3, content_layer2);
   }
 
-  properties.io_surface.reset(gfx::CreateIOSurface(
-      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR));
-  properties.cv_pixel_buffer.reset();
+  properties.gl_image->Destroy(true);
+  properties.gl_image = CreateGLImage(
+      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR, false);
 
   // Pass a frame that is clipped.
   properties.contents_rect = gfx::RectF(0, 0, 1, 0.9);
   {
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     transform_layer = [[clip_and_sorting_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
-    content_layer3 = [[transform_layer sublayers] objectAtIndex:0];
+    content_layer4 = [[transform_layer sublayers] objectAtIndex:0];
 
     // Validate the content layer.
-    EXPECT_FALSE([content_layer3
+    EXPECT_FALSE([content_layer4
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
-    EXPECT_NE(content_layer3, content_layer2);
+    EXPECT_NE(content_layer4, content_layer3);
   }
 }
 
 // Test fullscreen low power detection.
 TEST_F(CALayerTreeTest, FullscreenLowPower) {
   CALayerProperties properties;
-  properties.io_surface.reset(gfx::CreateIOSurface(
-      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR));
+  properties.gl_image = CreateGLImage(
+      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR, true);
   properties.is_clipped = false;
-  CVPixelBufferCreateWithIOSurface(nullptr, properties.io_surface, nullptr,
-                                   properties.cv_pixel_buffer.InitializeInto());
 
   CALayerProperties properties_black;
   properties_black.is_clipped = false;
   properties_black.background_color = SK_ColorBLACK;
   CALayerProperties properties_white;
   properties_white.is_clipped = false;
   properties_white.background_color = SK_ColorWHITE;
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree;
 
@@ skipping 118 matching lines @@
     CALayer* content_layer = [[transform_layer sublayers] objectAtIndex:0];
 
     // Validate the content layer and fullscreen low power mode.
     EXPECT_TRUE([content_layer
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
     EXPECT_FALSE(fullscreen_low_power_valid);
   }
 }
 
 }  // namespace gpu