Video to canvas: don't draw if a SkImage can't be created.

media/blink/skcanvas_video_renderer_unittest.cc

 // Copyright (c) 2012 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 "base/message_loop/message_loop.h"
+#include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/command_buffer/client/gles2_interface_stub.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/blink/skcanvas_video_renderer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 using media::VideoFrame;
 
 namespace media {
 
 static const int kWidth = 320;
 static const int kHeight = 240;
 static const gfx::RectF kNaturalRect(kWidth, kHeight);
 
@@ skipping 47 matching lines @@
 
   // Getters for various frame sizes.
   scoped_refptr<VideoFrame> natural_frame() { return natural_frame_; }
   scoped_refptr<VideoFrame> larger_frame() { return larger_frame_; }
   scoped_refptr<VideoFrame> smaller_frame() { return smaller_frame_; }
   scoped_refptr<VideoFrame> cropped_frame() { return cropped_frame_; }
 
   // Standard canvas.
   SkCanvas* target_canvas() { return &target_canvas_; }
 
- private:
+ protected:
   SkCanvasVideoRenderer renderer_;
 
   scoped_refptr<VideoFrame> natural_frame_;
   scoped_refptr<VideoFrame> larger_frame_;
   scoped_refptr<VideoFrame> smaller_frame_;
   scoped_refptr<VideoFrame> cropped_frame_;
 
   SkCanvas target_canvas_;
   base::MessageLoop message_loop_;
 
@@ skipping 389 matching lines @@
   EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, (kWidth / 2) - 1, 0));
   EXPECT_EQ(SK_ColorMAGENTA,
             GetColorAt(&canvas, (kWidth / 2) - 1, (kHeight / 2) - 1));
   EXPECT_EQ(SK_ColorMAGENTA, GetColorAt(&canvas, 0, (kHeight / 2) - 1));
   EXPECT_EQ(SK_ColorRED, GetColorAt(&canvas, kWidth / 2, kHeight / 2));
   EXPECT_EQ(SK_ColorBLUE, GetColorAt(&canvas, kWidth - 1, kHeight / 2));
   EXPECT_EQ(SK_ColorGREEN, GetColorAt(&canvas, kWidth - 1, kHeight - 1));
   EXPECT_EQ(SK_ColorBLACK, GetColorAt(&canvas, kWidth / 2, kHeight - 1));
 }
 
+namespace {
+class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
+ public:
+  void GenTextures(GLsizei n, GLuint* textures) override {
+    DCHECK_EQ(1, n);
+    *textures = 1;
+  }
+};
+void MailboxHoldersReleased(uint32 sync_point) {}
+}  // namespace
+
+// Test that SkCanvasVideoRendererTest::Paint doesn't crash when GrContext is
+// abandoned.
+TEST_F(SkCanvasVideoRendererTest, ContextLost) {
+  skia::RefPtr<const GrGLInterface> null_interface =
+      skia::AdoptRef(GrGLCreateNullInterface());
+  auto gr_context = skia::AdoptRef(GrContext::Create(
+      kOpenGL_GrBackend,
+      reinterpret_cast<GrBackendContext>(null_interface.get())));
+  gr_context->abandonContext();
+
+  SkCanvas canvas(AllocBitmap(kWidth, kHeight));
+
+  TestGLES2Interface gles2;
+  Context3D context_3d(&gles2, gr_context.get());
+  gfx::Size size(kWidth, kHeight);
+  gpu::MailboxHolder mailbox(gpu::Mailbox::Generate(), GL_TEXTURE_RECTANGLE_ARB,
+                             0);
+  auto video_frame = VideoFrame::WrapNativeTexture(
+      PIXEL_FORMAT_UYVY, mailbox, base::Bind(MailboxHoldersReleased), size,
+      gfx::Rect(size), size, kNoTimestamp());
+
+  renderer_.Paint(video_frame, &canvas, kNaturalRect, 0xFF,
+                  SkXfermode::kSrcOver_Mode, VIDEO_ROTATION_90, context_3d);
+}
 }  // namespace media