[Ozone] Extends the lifetime of VaapiWrapper

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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_surface.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 206 matching lines @@
                                             OverlayTransform transform,
                                             GLImage* image,
                                             const Rect& bounds_rect,
                                             const RectF& crop_rect)
     : z_order(z_order),
       transform(transform),
       image(image),
       bounds_rect(bounds_rect),
       crop_rect(crop_rect) {}
 
 bool GLSurfaceOzoneSurfaceless::Overlay::ScheduleOverlayPlane(

[reveman, 2015/11/12 14:58:26]

why is this called after the image has been destroyed?

[william.xie1, 2015/11/12 15:37:43]

the image is in the unsubmitted_frames_, and will be scheduled to overlay when
swapbuffer. During video playback on overlay, if user reload the webpage, the
mediaplayer pipeline will be destroyed immediately, and the image will be
destroyed too. However, the image object itself is still valid as it is cached
in pending frames, so this CL fixes the issue by checking if the image is still
valid before scheduling it to overlay.

Just let me know if the explanation is not clear.

[spang, 2015/11/12 15:47:52]

If it was totally valid when scheduled, we can't just drop it on the floor here.

Probably unsubmitted_frames_ queuing logic should be moved to GbmSurfaceless.
Need to find a way to do the fence bits though.

[kalyank, 2015/11/12 16:36:52]

When Media pipeline is destroyed, callback for processing pixmap in GbmBuffer is
also invalid. That seems to be the problem for crash in case we need to do any
processing(Scaling/Format conversion) in GbmBuffer. Moving unsubmitted_frames_
to GbmSurfacless will fix it, if we handle any processing needs of the pixmap
before adding it to the queue. We can still have it as it is (Here I mean), if
we can ensure that any processing needs of the pixmap is handled before adding
it to the queue. 

     gfx::AcceleratedWidget widget) const {
-  return image->ScheduleOverlayPlane(widget, z_order, transform, bounds_rect,
-                                     crop_rect);
+  if (image->IsValid())
+    return image->ScheduleOverlayPlane(widget, z_order, transform, bounds_rect,
+                                       crop_rect);
+  return true;
 }
 
 GLSurfaceOzoneSurfaceless::PendingFrame::PendingFrame() : ready(false) {}
 
 bool GLSurfaceOzoneSurfaceless::PendingFrame::ScheduleOverlayPlanes(
     gfx::AcceleratedWidget widget) {
   for (const auto& overlay : overlays)
     if (!overlay.ScheduleOverlayPlane(widget))
       return false;
   return true;
@@ skipping 473 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx