Remove LazyInstance usage from media/

media/mojo/services/mojo_cdm_service.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/mojo/services/mojo_cdm_service.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
 #include "media/base/cdm_config.h"
 #include "media/base/cdm_context.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/key_systems.h"
 #include "media/mojo/common/media_type_converters.h"
 #include "media/mojo/services/mojo_cdm_service_context.h"
 #include "url/gurl.h"
 
 namespace media {
 
 namespace {
 
 // Manages all CDMs created by MojoCdmService. Can only have one instance per
-// process so use a LazyInstance to ensure this.
+// process, so we use a thread-safe static to achieve this.
 class CdmManager {
  public:
   CdmManager() {}
   ~CdmManager() {}
 
   // Returns the CDM associated with |cdm_id|. Can be called on any thread.
   scoped_refptr<ContentDecryptionModule> GetCdm(int cdm_id) {
     base::AutoLock lock(lock_);
     auto iter = cdm_map_.find(cdm_id);
     return iter == cdm_map_.end() ? nullptr : iter->second;
@@ skipping 15 matching lines @@
   }
 
  private:
   // Lock to protect |cdm_map_|.
   base::Lock lock_;
   std::map<int, scoped_refptr<ContentDecryptionModule>> cdm_map_;
 
   DISALLOW_COPY_AND_ASSIGN(CdmManager);
 };
 
-base::LazyInstance<CdmManager>::Leaky g_cdm_manager = LAZY_INSTANCE_INITIALIZER;
+CdmManager* GetManager() {
+  static CdmManager* manager = new CdmManager();
+  return manager;
+}
 
 }  // namespace
 
 using SimpleMojoCdmPromise = MojoCdmPromise<>;
 using NewSessionMojoCdmPromise = MojoCdmPromise<std::string>;
 
 int MojoCdmService::next_cdm_id_ = CdmContext::kInvalidCdmId + 1;
 
 // static
 scoped_refptr<ContentDecryptionModule> MojoCdmService::LegacyGetCdm(
     int cdm_id) {
   DVLOG(1) << __func__ << ": " << cdm_id;
-  return g_cdm_manager.Get().GetCdm(cdm_id);
+  return GetManager()->GetCdm(cdm_id);
 }
 
 MojoCdmService::MojoCdmService(base::WeakPtr<MojoCdmServiceContext> context,
                                CdmFactory* cdm_factory)
     : context_(context),
       cdm_factory_(cdm_factory),
       cdm_id_(CdmContext::kInvalidCdmId),
       weak_factory_(this) {
   DCHECK(context_);
   DCHECK(cdm_factory_);
 }
 
 MojoCdmService::~MojoCdmService() {
   if (cdm_id_ == CdmContext::kInvalidCdmId)
     return;
 
-  g_cdm_manager.Get().UnregisterCdm(cdm_id_);
+  GetManager()->UnregisterCdm(cdm_id_);
 
   if (context_)
     context_->UnregisterCdm(cdm_id_);
 }
 
 void MojoCdmService::SetClient(mojom::ContentDecryptionModuleClientPtr client) {
   client_ = std::move(client);
 }
 
 void MojoCdmService::Initialize(const std::string& key_system,
@@ skipping 81 matching lines @@
     cdm_promise_result->system_code = 0;
     cdm_promise_result->error_message = error_message;
     callback.Run(std::move(cdm_promise_result), 0, nullptr);
     return;
   }
 
   cdm_ = cdm;
   cdm_id_ = next_cdm_id_++;
 
   context_->RegisterCdm(cdm_id_, this);
-  g_cdm_manager.Get().RegisterCdm(cdm_id_, cdm);
+  GetManager()->RegisterCdm(cdm_id_, cdm);
 
   // If |cdm| has a decryptor, create the MojoDecryptorService
   // and pass the connection back to the client.
   mojom::DecryptorPtr decryptor_service;
   CdmContext* const cdm_context = cdm_->GetCdmContext();
   if (cdm_context && cdm_context->GetDecryptor()) {
     // MojoDecryptorService takes a reference to the CDM, but it is still owned
     // by |this|.
     decryptor_.reset(new MojoDecryptorService(
         cdm_, MakeRequest(&decryptor_service),
@@ skipping 41 matching lines @@
 
 void MojoCdmService::OnDecryptorConnectionError() {
   DVLOG(2) << __func__;
 
   // MojoDecryptorService has lost connectivity to it's client, so it can be
   // freed.
   decryptor_.reset();
 }
 
 }  // namespace media