Remove LazyInstance usage from media/

media/capture/video/linux/video_capture_device_chromeos.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 "media/capture/video/linux/video_capture_device_chromeos.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
-#include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "ui/display/display.h"
 #include "ui/display/display_observer.h"
 #include "ui/display/screen.h"
 
 namespace media {
 
-namespace {
-
-base::LazyInstance<CameraConfigChromeOS>::Leaky g_camera_config_ =
-    LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
+static CameraConfigChromeOS* GetCameraConfig() {
+  static CameraConfigChromeOS* config = new CameraConfigChromeOS();
+  return config;
+}
 
 // This is a delegate class used to transfer Display change events from the UI
 // thread to the media thread.
 class VideoCaptureDeviceChromeOS::ScreenObserverDelegate
     : public display::DisplayObserver,
       public base::RefCountedThreadSafe<ScreenObserverDelegate> {
  public:
   ScreenObserverDelegate(
       VideoCaptureDeviceChromeOS* capture_device,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
@@ skipping 65 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(ScreenObserverDelegate);
 };
 
 VideoCaptureDeviceChromeOS::VideoCaptureDeviceChromeOS(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     const VideoCaptureDeviceDescriptor& device_descriptor)
     : VideoCaptureDeviceLinux(device_descriptor),
       screen_observer_delegate_(
           new ScreenObserverDelegate(this, ui_task_runner)),
       lens_facing_(
-          g_camera_config_.Get().GetCameraFacing(device_descriptor.device_id,
-                                                 device_descriptor.model_id)),
+          GetCameraConfig()->GetCameraFacing(device_descriptor.device_id,

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

Since GetCameraConfig() is only called from this one constructor, consider
putting the static in-line in the constructor body and getting rid of the helper
function. This will only be palatable if you can initialize (and are OK with
initializing) these member variables from the constructor body instead of its
initializer list.

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

Class marks those variables as const which is why I went with the external
function approach here.

+                                             device_descriptor.model_id)),
       camera_orientation_(
-          g_camera_config_.Get().GetOrientation(device_descriptor.device_id,
-                                                device_descriptor.model_id)) {}
+          GetCameraConfig()->GetOrientation(device_descriptor.device_id,
+                                            device_descriptor.model_id)) {}
 
 VideoCaptureDeviceChromeOS::~VideoCaptureDeviceChromeOS() {
   screen_observer_delegate_->RemoveObserver();
 }
 
 void VideoCaptureDeviceChromeOS::SetRotation(int rotation) {
   // We assume external camera is facing the users. If not, the users can
   // rotate the camera manually by themselves.
   if (lens_facing_ == VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT) {
     // Original frame when |rotation| = 0
@@ skipping 34 matching lines @@
   VideoCaptureDeviceLinux::SetRotation(rotation);
 }
 
 void VideoCaptureDeviceChromeOS::SetDisplayRotation(
     const display::Display& display) {
   if (display.IsInternal())
     SetRotation(display.rotation() * 90);
 }
 
 }  // namespace media