Remove LazyInstance usage from media/

media/midi/midi_manager_alsa.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/midi/midi_manager_alsa.h"
 
 #include <errno.h>
 #include <poll.h>
 #include <stddef.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 64 matching lines @@
     SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_NO_EXPORT;
 const unsigned int kCreateInputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_NO_EXPORT;
 const unsigned int kCreatePortType =
     SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION;
 
 // Global variables to identify MidiManagerAlsa instance.
 const int kInvalidInstanceId = -1;
 int g_active_instance_id = kInvalidInstanceId;
 int g_next_instance_id = 0;
-base::LazyInstance<base::Lock> g_instance_id_lock = LAZY_INSTANCE_INITIALIZER;
 
-// Prevent current instance from quiting Finalize() while tasks run on external
-// TaskRunners.
-base::LazyInstance<base::Lock> g_event_task_lock = LAZY_INSTANCE_INITIALIZER;
-base::LazyInstance<base::Lock> g_send_task_lock = LAZY_INSTANCE_INITIALIZER;
+struct MidiManagerLockHelper {
+  base::Lock instance_id_lock;
+
+  // Prevent current instance from quiting Finalize() while tasks run on
+  // external TaskRunners.
+  base::Lock event_task_lock;
+  base::Lock send_task_lock;
+};
+
+MidiManagerLockHelper* GetLockHelper() {
+  static MidiManagerLockHelper* lock_helper = new MidiManagerLockHelper();
+  return lock_helper;
+}
 
 int AddrToInt(int client, int port) {
   return (client << 8) | port;
 }
 
 // Returns true if this client has an ALSA card associated with it.
 bool IsCardClient(snd_seq_client_type_t type, int client_id) {
   return (type == SND_SEQ_KERNEL_CLIENT) &&
          (client_id >= kMinimumClientIdForCards);
 }
@@ skipping 59 matching lines @@
   base::AutoLock lock(lazy_init_member_lock_);
 
   // Extra CHECK to verify all members are already reset.
   CHECK(!initialization_thread_checker_);
   CHECK(!in_client_);
   CHECK(!out_client_);
   CHECK(!decoder_);
   CHECK(!udev_);
   CHECK(!udev_monitor_);
 
-  base::AutoLock instance_id_lock(g_instance_id_lock.Get());
+  base::AutoLock instance_id_lock(GetLockHelper()->instance_id_lock);
   CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
 }
 
 void MidiManagerAlsa::StartInitialization() {
   {
-    base::AutoLock lock(g_instance_id_lock.Get());
+    base::AutoLock lock(GetLockHelper()->instance_id_lock);
     CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
     instance_id_ = g_next_instance_id++;
     g_active_instance_id = instance_id_;
   }
 
   base::AutoLock lock(lazy_init_member_lock_);
 
   initialization_thread_checker_.reset(new base::ThreadChecker());
 
   // Create client handles.
@@ skipping 115 matching lines @@
 }
 
 void MidiManagerAlsa::Finalize() {
   base::AutoLock lock(lazy_init_member_lock_);
   DCHECK(initialization_thread_checker_->CalledOnValidThread());
 
   // Tell tasks running on TaskRunners it will soon be time to shut down. This
   // gives us assurance a task running on kEventTaskRunner will stop in case the
   // SND_SEQ_EVENT_CLIENT_EXIT message is lost.
   {
-    base::AutoLock lock(g_instance_id_lock.Get());
+    base::AutoLock lock(GetLockHelper()->instance_id_lock);
     CHECK_EQ(instance_id_, g_active_instance_id);
     g_active_instance_id = kInvalidInstanceId;
   }
 
   // Ensure that no tasks run on kSendTaskRunner.
-  base::AutoLock send_runner_lock(g_send_task_lock.Get());
+  base::AutoLock send_runner_lock(GetLockHelper()->send_task_lock);
 
   // Close the out client. This will trigger the event thread to stop,
   // because of SND_SEQ_EVENT_CLIENT_EXIT.
   out_client_.reset();
 
   // Ensure that no tasks run on kEventTaskRunner.
-  base::AutoLock event_runner_lock(g_event_task_lock.Get());
+  base::AutoLock event_runner_lock(GetLockHelper()->event_task_lock);
 
   // Destruct the other stuff we initialized in StartInitialization().
   udev_monitor_.reset();
   udev_.reset();
   decoder_.reset();
   in_client_.reset();
   initialization_thread_checker_.reset();
 }
 
 void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
@@ skipping 532 matching lines @@
 }
 
 void MidiManagerAlsa::SendMidiData(int instance_id,
                                    MidiManagerClient* client,
                                    uint32_t port_index,
                                    const std::vector<uint8_t>& data) {
   DCHECK(service()->GetTaskRunner(kSendTaskRunner)->BelongsToCurrentThread());
 
   // Obtain the lock so that the instance could not be destructed while this
   // method is running on the kSendTaskRunner.
-  base::AutoLock lock(g_send_task_lock.Get());
+  base::AutoLock lock(GetLockHelper()->send_task_lock);
   {
     // Check if Finalize() already runs. After this check, we can access |this|
     // safely on the kEventTaskRunner.
-    base::AutoLock instance_id_lock(g_instance_id_lock.Get());
+    base::AutoLock instance_id_lock(GetLockHelper()->instance_id_lock);
     if (instance_id != g_active_instance_id)
       return;
   }
 
   snd_midi_event_t* encoder;
   snd_midi_event_new(kSendBufferSize, &encoder);
   for (const auto datum : data) {
     snd_seq_event_t event;
     int result = snd_midi_event_encode_byte(encoder, datum, &event);
     if (result == 1) {
@@ skipping 10 matching lines @@
   }
   snd_midi_event_free(encoder);
 
   // Acknowledge send.
   AccumulateMidiBytesSent(client, data.size());
 }
 
 void MidiManagerAlsa::EventLoop(int instance_id) {
   // Obtain the lock so that the instance could not be destructed while this
   // method is running on the kEventTaskRunner.
-  base::AutoLock lock(g_event_task_lock.Get());
+  base::AutoLock lock(GetLockHelper()->event_task_lock);
   {
     // Check if Finalize() already runs. After this check, we can access |this|
     // safely on the kEventTaskRunner.
-    base::AutoLock instance_id_lock(g_instance_id_lock.Get());
+    base::AutoLock instance_id_lock(GetLockHelper()->instance_id_lock);
     if (instance_id != g_active_instance_id)
       return;
   }
 
   bool loop_again = true;
 
   struct pollfd pfd[2];
   snd_seq_poll_descriptors(in_client_.get(), &pfd[0], 1, POLLIN);
   pfd[1].fd = device::udev_monitor_get_fd(udev_monitor_.get());
   pfd[1].events = POLLIN;
@@ skipping 496 matching lines @@
   // Update our map.
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create(MidiService* service) {
   return new MidiManagerAlsa(service);
 }
 
 }  // namespace midi