[Ozone] Extends the lifetime of VaapiWrapper

content/common/gpu/media/vaapi_drm_picture.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 "base/file_descriptor_posix.h"
 #include "content/common/gpu/media/va_surface.h"
 #include "content/common/gpu/media/vaapi_drm_picture.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #include "third_party/libva/va/drm/va_drm.h"
 #include "third_party/libva/va/va.h"
 #include "third_party/libva/va/va_drmcommon.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image_ozone_native_pixmap.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace content {
 
 VaapiDrmPicture::VaapiDrmPicture(
-    VaapiWrapper* vaapi_wrapper,
+    scoped_refptr<VaapiWrapper> vaapi_wrapper,
     const base::Callback<bool(void)>& make_context_current,
     int32 picture_buffer_id,
     uint32 texture_id,
     const gfx::Size& size)
     : VaapiPicture(picture_buffer_id, texture_id, size),
       vaapi_wrapper_(vaapi_wrapper),
-      make_context_current_(make_context_current),
-      weak_this_factory_(this) {
-}
+      make_context_current_(make_context_current) {}
 
 VaapiDrmPicture::~VaapiDrmPicture() {
   if (gl_image_ && make_context_current_.Run()) {
     gl_image_->ReleaseTexImage(GL_TEXTURE_EXTERNAL_OES);
     gl_image_->Destroy(true);
 
+    LOG(WARNING) << "qxie2:" << __FUNCTION__ << ", gl_image:" << gl_image_;
     DCHECK_EQ(glGetError(), static_cast<GLenum>(GL_NO_ERROR));
   }
 }
 
 scoped_refptr<VASurface> VaapiDrmPicture::CreateVASurfaceForPixmap(
     scoped_refptr<ui::NativePixmap> pixmap,
     gfx::Size pixmap_size) {
   // Get the dmabuf of the created buffer.
   int dmabuf_fd = pixmap->GetDmaBufFd();
   if (dmabuf_fd < 0) {
@@ skipping 60 matching lines @@
     LOG(ERROR) << "Failed creating an Ozone NativePixmap";
     return false;
   }
 
   va_surface_ = CreateVASurfaceForPixmap(pixmap_, size());
   if (!va_surface_) {
     LOG(ERROR) << "Failed creating VASurface for NativePixmap";
     return false;
   }
 
-  // Weak pointers can only bind to methods without return values,
-  // hence we cannot bind ScalePixmap here. Instead we use a
-  // static function to solve this problem.
-  pixmap_->SetScalingCallback(base::Bind(&VaapiDrmPicture::CallScalePixmap,
-                                         weak_this_factory_.GetWeakPtr()));
+  scoped_refptr<VaapiDrmPicture> ref = this;

[Pawel Osciak, 2015/11/16 04:24:35]

This shouldn't be required. You should be able to pass this directly to Bind.

[william.xie1, 2015/11/16 08:07:25]

Done.

+  pixmap_->SetScalingCallback(base::Bind(&VaapiDrmPicture::ScalePixmap, ref));
 
   if (!make_context_current_.Run())
     return false;
 
   gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_EXTERNAL_OES,
                                           texture_id());
   scoped_refptr<gfx::GLImageOzoneNativePixmap> image(
       new gfx::GLImageOzoneNativePixmap(size(), GL_BGRA_EXT));
   if (!image->Initialize(pixmap_.get(), gfx::BufferFormat::BGRX_8888)) {
     LOG(ERROR) << "Failed to create GLImage";
     return false;
   }
   gl_image_ = image;
   if (!gl_image_->BindTexImage(GL_TEXTURE_EXTERNAL_OES)) {
     LOG(ERROR) << "Failed to bind texture to GLImage";
     return false;
   }
 
   return true;
 }
 
 bool VaapiDrmPicture::DownloadFromSurface(
     const scoped_refptr<VASurface>& va_surface) {
   return vaapi_wrapper_->BlitSurface(va_surface, va_surface_);
 }
 
-// static
-scoped_refptr<ui::NativePixmap> VaapiDrmPicture::CallScalePixmap(
-    base::WeakPtr<VaapiDrmPicture> weak_ptr,
-    gfx::Size new_size) {
-  if (!weak_ptr.get()) {
-    LOG(ERROR) << "Failed scaling NativePixmap as scaling "
-                  "unit(VaapiDrmPicture) is deleted";
-    return nullptr;
-  }
-  return weak_ptr->ScalePixmap(new_size);
-}
-
 scoped_refptr<ui::NativePixmap> VaapiDrmPicture::ScalePixmap(
     gfx::Size new_size) {
   if (!scaled_va_surface_.get() || scaled_va_surface_->size() != new_size) {
     scaled_pixmap_ = CreateNativePixmap(new_size);
     if (!scaled_pixmap_) {
       LOG(ERROR) << "Failed creating an Ozone NativePixmap for scaling";
       scaled_va_surface_ = nullptr;
       return nullptr;
     }
     scaled_va_surface_ = CreateVASurfaceForPixmap(scaled_pixmap_, new_size);
@@ skipping 19 matching lines @@
 
 scoped_refptr<gl::GLImage> VaapiDrmPicture::GetImageToBind() {
   return gl_image_;
 }
 
 bool VaapiDrmPicture::AllowOverlay() const {
   return true;
 }
 
 }  // namespace