Remove LazyInstance usage from media/

media/gpu/vaapi_wrapper.cc

 // Copyright 2013 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 "media/gpu/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 86 matching lines @@
 
 }  // namespace
 #endif
 
 namespace media {
 
 // Maximum framerate of encoded profile. This value is an arbitary limit
 // and not taken from HW documentation.
 const int kMaxEncoderFramerate = 30;
 
-base::LazyInstance<VaapiWrapper::VADisplayState>
-    VaapiWrapper::va_display_state_ = LAZY_INSTANCE_INITIALIZER;
-
-base::LazyInstance<VaapiWrapper::LazyProfileInfos>
-    VaapiWrapper::profile_infos_ = LAZY_INSTANCE_INITIALIZER;
-
 // Config attributes common for both encode and decode.
 static const VAConfigAttrib kCommonVAConfigAttribs[] = {
     {VAConfigAttribRTFormat, VA_RT_FORMAT_YUV420},
 };
 
 // Attributes required for encode.
 static const VAConfigAttrib kEncodeVAConfigAttribs[] = {
     {VAConfigAttribRateControl, VA_RC_CBR},
     {VAConfigAttribEncPackedHeaders,
      VA_ENC_PACKED_HEADER_SEQUENCE | VA_ENC_PACKED_HEADER_PICTURE},
@@ skipping 47 matching lines @@
 }
 
 VaapiWrapper::VaapiWrapper()
     : va_surface_format_(0),
       va_display_(NULL),
       va_config_id_(VA_INVALID_ID),
       va_context_id_(VA_INVALID_ID),
       va_vpp_config_id_(VA_INVALID_ID),
       va_vpp_context_id_(VA_INVALID_ID),
       va_vpp_buffer_id_(VA_INVALID_ID) {
-  va_lock_ = va_display_state_.Get().va_lock();
+  va_lock_ = GetDisplayState()->va_lock();
 }
 
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   DeinitializeVpp();
   Deinitialize();
 }
 
 // static
 scoped_refptr<VaapiWrapper> VaapiWrapper::Create(
     CodecMode mode,
     VAProfile va_profile,
     const base::Closure& report_error_to_uma_cb) {
-  if (!profile_infos_.Get().IsProfileSupported(mode, va_profile)) {
+  if (!GetProfileInfos()->IsProfileSupported(mode, va_profile)) {
     DVLOG(1) << "Unsupported va_profile: " << va_profile;
     return nullptr;
   }
 
   scoped_refptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
   if (vaapi_wrapper->VaInitialize(report_error_to_uma_cb)) {
     if (vaapi_wrapper->Initialize(mode, va_profile))
       return vaapi_wrapper;
   }
   LOG(ERROR) << "Failed to create VaapiWrapper for va_profile: " << va_profile;
   return nullptr;
 }
 
 // static
 scoped_refptr<VaapiWrapper> VaapiWrapper::CreateForVideoCodec(
     CodecMode mode,
     VideoCodecProfile profile,
     const base::Closure& report_error_to_uma_cb) {
   VAProfile va_profile = ProfileToVAProfile(profile, mode);
   scoped_refptr<VaapiWrapper> vaapi_wrapper =
       Create(mode, va_profile, report_error_to_uma_cb);
   return vaapi_wrapper;
 }
 
 // static
 VideoEncodeAccelerator::SupportedProfiles
 VaapiWrapper::GetSupportedEncodeProfiles() {
   VideoEncodeAccelerator::SupportedProfiles profiles;
   std::vector<ProfileInfo> encode_profile_infos =
-      profile_infos_.Get().GetSupportedProfileInfosForCodecMode(kEncode);
+      GetProfileInfos()->GetSupportedProfileInfosForCodecMode(kEncode);
 
   for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
     VAProfile va_profile = ProfileToVAProfile(kProfileMap[i].profile, kEncode);
     if (va_profile == VAProfileNone)
       continue;
     for (const auto& profile_info : encode_profile_infos) {
       if (profile_info.va_profile == va_profile) {
         VideoEncodeAccelerator::SupportedProfile profile;
         profile.profile = kProfileMap[i].profile;
         profile.max_resolution = profile_info.max_resolution;
         profile.max_framerate_numerator = kMaxEncoderFramerate;
         profile.max_framerate_denominator = 1;
         profiles.push_back(profile);
         break;
       }
     }
   }
   return profiles;
 }
 
 // static
 VideoDecodeAccelerator::SupportedProfiles
 VaapiWrapper::GetSupportedDecodeProfiles() {
   VideoDecodeAccelerator::SupportedProfiles profiles;
   std::vector<ProfileInfo> decode_profile_infos =
-      profile_infos_.Get().GetSupportedProfileInfosForCodecMode(kDecode);
+      GetProfileInfos()->GetSupportedProfileInfosForCodecMode(kDecode);
 
   for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
     VAProfile va_profile = ProfileToVAProfile(kProfileMap[i].profile, kDecode);
     if (va_profile == VAProfileNone)
       continue;
     for (const auto& profile_info : decode_profile_infos) {
       if (profile_info.va_profile == va_profile) {
         VideoDecodeAccelerator::SupportedProfile profile;
         profile.profile = kProfileMap[i].profile;
         profile.max_resolution = profile_info.max_resolution;
         profile.min_resolution.SetSize(16, 16);
         profiles.push_back(profile);
         break;
       }
     }
   }
   return profiles;
 }
 
 // static
 bool VaapiWrapper::IsJpegDecodeSupported() {
-  return profile_infos_.Get().IsProfileSupported(kDecode,
-                                                 VAProfileJPEGBaseline);
+  return GetProfileInfos()->IsProfileSupported(kDecode, VAProfileJPEGBaseline);
 }
 
 void VaapiWrapper::TryToSetVADisplayAttributeToLocalGPU() {
   base::AutoLock auto_lock(*va_lock_);
   VADisplayAttribute item = {VADisplayAttribRenderMode,
                              1,   // At least support '_LOCAL_OVERLAY'.
                              -1,  // The maximum possible support 'ALL'.
                              VA_RENDER_MODE_LOCAL_GPU,
                              VA_DISPLAY_ATTRIB_SETTABLE};
 
   VAStatus va_res = vaSetDisplayAttributes(va_display_, &item, 1);
   if (va_res != VA_STATUS_SUCCESS)
     DVLOG(2) << "vaSetDisplayAttributes unsupported, ignoring by default.";
 }
 
 // static
 VAProfile VaapiWrapper::ProfileToVAProfile(VideoCodecProfile profile,
                                            CodecMode mode) {
   VAProfile va_profile = VAProfileNone;
   for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
     if (kProfileMap[i].profile == profile) {
       va_profile = kProfileMap[i].va_profile;
       break;
     }
   }
-  if (!profile_infos_.Get().IsProfileSupported(mode, va_profile) &&
+  if (!GetProfileInfos()->IsProfileSupported(mode, va_profile) &&
       va_profile == VAProfileH264Baseline) {
     // crbug.com/345569: ProfileIDToVideoCodecProfile() currently strips
     // the information whether the profile is constrained or not, so we have no
     // way to know here. Try for baseline first, but if it is not supported,
     // try constrained baseline and hope this is what it actually is
     // (which in practice is true for a great majority of cases).
-    if (profile_infos_.Get().IsProfileSupported(
+    if (GetProfileInfos()->IsProfileSupported(
             mode, VAProfileH264ConstrainedBaseline)) {
       va_profile = VAProfileH264ConstrainedBaseline;
       DVLOG(1) << "Fall back to constrained baseline profile.";
     }
   }
   return va_profile;
 }
 
 std::vector<VaapiWrapper::ProfileInfo>
 VaapiWrapper::GetSupportedProfileInfosForCodecModeInternal(CodecMode mode) {
@@ skipping 38 matching lines @@
     if (running_on_chromeos)
       LOG(ERROR) << kErrorMsg;
     else
       DVLOG(1) << kErrorMsg;
     return false;
   }
 
   report_error_to_uma_cb_ = report_error_to_uma_cb;
 
   base::AutoLock auto_lock(*va_lock_);
-
-  VADisplayState* va_display_state = &va_display_state_.Get();
-  if (!va_display_state) {
-    LOG(ERROR) << "Failed to allocate VA display state";
-    return false;
-  }
-
-  if (!va_display_state->Initialize())
+  if (!GetDisplayState()->Initialize())
     return false;
 
-  va_display_ = va_display_state->va_display();
+  va_display_ = GetDisplayState()->va_display();
   return true;
 }
 
 bool VaapiWrapper::GetSupportedVaProfiles(std::vector<VAProfile>* profiles) {
   base::AutoLock auto_lock(*va_lock_);
   // Query the driver for supported profiles.
   int max_profiles = vaMaxNumProfiles(va_display_);
   std::vector<VAProfile> supported_profiles(
       base::checked_cast<size_t>(max_profiles));
 
@@ skipping 125 matching lines @@
 }
 
 void VaapiWrapper::Deinitialize() {
   base::AutoLock auto_lock(*va_lock_);
 
   if (va_config_id_ != VA_INVALID_ID) {
     VAStatus va_res = vaDestroyConfig(va_display_, va_config_id_);
     VA_LOG_ON_ERROR(va_res, "vaDestroyConfig failed");
   }
 
-  VADisplayState* va_display_state = &va_display_state_.Get();
-  if (va_display_state) {
-    VAStatus va_res = VA_STATUS_SUCCESS;
-    va_display_state->Deinitialize(&va_res);
-    VA_LOG_ON_ERROR(va_res, "vaTerminate failed");
-  }
+  VAStatus va_res = VA_STATUS_SUCCESS;
+  GetDisplayState()->Deinitialize(&va_res);
+  VA_LOG_ON_ERROR(va_res, "vaTerminate failed");
 
   va_config_id_ = VA_INVALID_ID;
   va_display_ = NULL;
 }
 
 bool VaapiWrapper::CreateSurfaces(unsigned int va_format,
                                   const gfx::Size& size,
                                   size_t num_surfaces,
                                   std::vector<VASurfaceID>* va_surfaces) {
   base::AutoLock auto_lock(*va_lock_);
@@ skipping 600 matching lines @@
 }
 
 // static
 void VaapiWrapper::PreSandboxInitialization() {
 #if defined(USE_OZONE)
   const char kDriRenderNode0Path[] = "/dev/dri/renderD128";
   base::File drm_file = base::File(
       base::FilePath::FromUTF8Unsafe(kDriRenderNode0Path),
       base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE);
   if (drm_file.IsValid())
-    va_display_state_.Get().SetDrmFd(drm_file.GetPlatformFile());
+    GetDisplayState()->SetDrmFd(drm_file.GetPlatformFile());
 #endif
 }
 
 // static
 bool VaapiWrapper::PostSandboxInitialization() {
   StubPathMap paths;
 
   paths[kModuleVa].push_back("libva.so.1");
 
 #if defined(USE_X11)
   paths[kModuleVa_x11].push_back("libva-x11.so.1");
 #elif defined(USE_OZONE)
   paths[kModuleVa_drm].push_back("libva-drm.so.1");
 #endif
 
   return InitializeStubs(paths);
 }
 
+// static
+VaapiWrapper::VADisplayState* VaapiWrapper::GetDisplayState() {
+  static VADisplayState* display_state = new VADisplayState();
+  return display_state;
+}
+
+// static
+VaapiWrapper::LazyProfileInfos* VaapiWrapper::GetProfileInfos() {
+  static LazyProfileInfos* profile_infos = new LazyProfileInfos();
+  return profile_infos;
+}
+
 VaapiWrapper::LazyProfileInfos::LazyProfileInfos() {
   static_assert(arraysize(supported_profiles_) == kCodecModeMax,
                 "The array size of supported profile is incorrect.");
   scoped_refptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
   if (!vaapi_wrapper->VaInitialize(base::Bind(&base::DoNothing)))
     return;
   for (size_t i = 0; i < kCodecModeMax; ++i) {
     supported_profiles_[i] =
         vaapi_wrapper->GetSupportedProfileInfosForCodecModeInternal(
             static_cast<CodecMode>(i));
@@ skipping 80 matching lines @@
   drm_fd_.reset(HANDLE_EINTR(dup(fd)));
 }
 #endif  // USE_OZONE
 
 bool VaapiWrapper::VADisplayState::VAAPIVersionLessThan(int major, int minor) {
   return (major_version_ < major) ||
          (major_version_ == major && minor_version_ < minor);
 }
 
 }  // namespace media