Remove LazyInstance usage from media/

media/gpu/vaapi_wrapper.h

 // 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.
 //
 // This file contains an implementation of VaapiWrapper, used by
 // VaapiVideoDecodeAccelerator and VaapiH264Decoder for decode,
 // and VaapiVideoEncodeAccelerator for encode, to interface
 // with libva (VA-API library for hardware video codec).
 
 #ifndef MEDIA_GPU_VAAPI_WRAPPER_H_
 #define MEDIA_GPU_VAAPI_WRAPPER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <vector>
 
 #include "base/files/file.h"
-#include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/gpu/media_gpu_export.h"
 #include "media/gpu/va_surface.h"
 #include "media/video/jpeg_decode_accelerator.h"
 #include "media/video/video_decode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
@@ skipping 219 matching lines @@
     void Deinitialize(VAStatus* status);
 
     base::Lock* va_lock() { return &va_lock_; }
     VADisplay va_display() const { return va_display_; }
 
 #if defined(USE_OZONE)
     void SetDrmFd(base::PlatformFile fd);
 #endif  // USE_OZONE
 
    private:
-    friend class base::LazyInstance<VADisplayState>;
-
     // Returns true if the VAAPI version is less than the specified version.
     bool VAAPIVersionLessThan(int major, int minor);
 
     // Protected by |va_lock_|.
     int refcount_;
 
     // Libva is not thread safe, so we have to do locking for it ourselves.
     // This lock is to be taken for the duration of all VA-API calls and for
     // the entire job submission sequence in ExecuteAndDestroyPendingBuffers().
     base::Lock va_lock_;
@@ skipping 66 matching lines @@
   // Lazily initialize static data after sandbox is enabled.  Return false on
   // init failure.
   static bool PostSandboxInitialization();
 
   // Map VideoCodecProfile enum values to VaProfile values. This function
   // includes a workaround for crbug.com/345569. If va_profile is h264 baseline
   // and it is not supported, we try constrained baseline.
   static VAProfile ProfileToVAProfile(VideoCodecProfile profile,
                                       CodecMode mode);
 
+  // Singleton accessors.
+  static VADisplayState* GetDisplayState();
+  static LazyProfileInfos* GetProfileInfos();
+
   // Pointer to VADisplayState's member |va_lock_|. Guaranteed to be valid for
   // the lifetime of VaapiWrapper.
   base::Lock* va_lock_;
 
   // Allocated ids for VASurfaces.
   std::vector<VASurfaceID> va_surface_ids_;
 
   // VA format of surfaces with va_surface_ids_.
   unsigned int va_surface_format_;
 
-  // Singleton instance of VADisplayState.
-  static base::LazyInstance<VADisplayState> va_display_state_;
-
   // VA handles.
   // All valid after successful Initialize() and until Deinitialize().
   VADisplay va_display_;
   VAConfigID va_config_id_;
   // Created for the current set of va_surface_ids_ in CreateSurfaces() and
   // valid until DestroySurfaces().
   VAContextID va_context_id_;
 
   // Data queued up for HW codec, to be committed on next execution.
   std::vector<VABufferID> pending_slice_bufs_;
   std::vector<VABufferID> pending_va_bufs_;
 
   // Bitstream buffers for encode.
   std::set<VABufferID> coded_buffers_;
 
   // Called to report codec errors to UMA. Errors to clients are reported via
   // return values from public methods.
   base::Closure report_error_to_uma_cb_;
 
   // VPP (Video Post Processing) context, this is used to convert
   // pictures used by the decoder to RGBA pictures usable by GL or the
   // display hardware.
   VAConfigID va_vpp_config_id_;
   VAContextID va_vpp_context_id_;
   VABufferID va_vpp_buffer_id_;
 
-  // Singleton variable to store supported profile information for encode and
-  // decode.
-  static base::LazyInstance<LazyProfileInfos> profile_infos_;
-
   DISALLOW_COPY_AND_ASSIGN(VaapiWrapper);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_VAAPI_WRAPPER_H_