Remove LazyInstance usage from media/

content/renderer/media/video_track_recorder.cc

 // Copyright 2015 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 "content/renderer/media/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 83 matching lines @@
   // VIDEO_CODEC_PROFILE_UNKNOWN otherwise.
   media::VideoCodecProfile CodecIdToVEAProfile(CodecId codec);
 
  private:
   // A map of VEA-supported CodecId-and-VEA-profile pairs.
   std::map<CodecId, media::VideoCodecProfile> codec_id_to_profile_;
 
   DISALLOW_COPY_AND_ASSIGN(CodecEnumerator);
 };
 
-static base::LazyInstance<CodecEnumerator>::Leaky g_codec_enumerator =
-    LAZY_INSTANCE_INITIALIZER;
+static CodecEnumerator* GetCodecEnumerator() {

[Mark Mentovai, 2017/01/31 21:33:56]

No need to write “static” in an unnamed namespace.

[DaleCurtis, 2017/01/31 22:04:33]

Done.

+  static CodecEnumerator* enumerator = new CodecEnumerator();
+  return enumerator;
+}
 
 CodecEnumerator::CodecEnumerator() {
 #if defined(OS_CHROMEOS)
   // See https://crbug.com/616659.
   return;
 #endif
 
 #if defined(OS_ANDROID)
   // See https://crbug.com/653864.
   return;
@@ skipping 995 matching lines @@
 
   int pixel_format = EVideoFormatType::videoFormatI420;
   openh264_encoder_->SetOption(ENCODER_OPTION_DATAFORMAT, &pixel_format);
 }
 #endif //#if BUILDFLAG(RTC_USE_H264)
 
 }  // anonymous namespace
 
 // static
 VideoTrackRecorder::CodecId VideoTrackRecorder::GetPreferredCodecId() {
-  return g_codec_enumerator.Get().GetPreferredCodecId();
+  return GetCodecEnumerator()->GetPreferredCodecId();
 }
 
 VideoTrackRecorder::VideoTrackRecorder(
     CodecId codec,
     const blink::WebMediaStreamTrack& track,
     const OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second)
     : track_(track),
       paused_before_init_(false),
       weak_ptr_factory_(this) {
@@ skipping 51 matching lines @@
     int32_t bits_per_second,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks capture_time) {
   DVLOG(3) << __func__ << frame->visible_rect().size().ToString();
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 
   MediaStreamVideoSink::DisconnectFromTrack();
 
   const gfx::Size& input_size = frame->visible_rect().size();
   const auto& vea_supported_profile =
-      g_codec_enumerator.Get().CodecIdToVEAProfile(codec);
+      GetCodecEnumerator()->CodecIdToVEAProfile(codec);
   if (vea_supported_profile != media::VIDEO_CODEC_PROFILE_UNKNOWN &&
       input_size.width() >= kVEAEncoderMinResolutionWidth &&
       input_size.height() >= kVEAEncoderMinResolutionHeight) {
     encoder_ = new VEAEncoder(on_encoded_video_callback, bits_per_second,
                               vea_supported_profile, input_size);
   } else {
     switch (codec) {
 #if BUILDFLAG(RTC_USE_H264)
       case CodecId::H264:
         encoder_ =
@@ skipping 14 matching lines @@
     encoder_->SetPaused(paused_before_init_);
 
   // StartFrameEncode() will be called on Render IO thread.
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       base::Bind(&VideoTrackRecorder::Encoder::StartFrameEncode, encoder_),
       false);
 }
 
 }  // namespace content