media: Add log in CdmSessionAdapter

media/blink/cdm_session_adapter.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/blink/cdm_session_adapter.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 83 matching lines @@
     CdmSessionType session_type,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   cdm_->CreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
                                         std::move(promise));
 }
 
 void CdmSessionAdapter::LoadSession(
     CdmSessionType session_type,
     const std::string& session_id,
     std::unique_ptr<NewSessionCdmPromise> promise) {
+  DVLOG(2) << __func__ << ": session_id = " << session_id;
   cdm_->LoadSession(session_type, session_id, std::move(promise));
 }
 
 void CdmSessionAdapter::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     std::unique_ptr<SimpleCdmPromise> promise) {
+  DVLOG(3) << __func__ << ": session_id = " << session_id;
   cdm_->UpdateSession(session_id, response, std::move(promise));
 }
 
 void CdmSessionAdapter::CloseSession(
     const std::string& session_id,
     std::unique_ptr<SimpleCdmPromise> promise) {
+  DVLOG(2) << __func__ << ": session_id = " << session_id;
   cdm_->CloseSession(session_id, std::move(promise));
 }
 
 void CdmSessionAdapter::RemoveSession(
     const std::string& session_id,
     std::unique_ptr<SimpleCdmPromise> promise) {
+  DVLOG(2) << __func__ << ": session_id = " << session_id;
   cdm_->RemoveSession(session_id, std::move(promise));
 }
 
 scoped_refptr<ContentDecryptionModule> CdmSessionAdapter::GetCdm() {
   return cdm_;
 }
 
 const std::string& CdmSessionAdapter::GetKeySystem() const {
   return key_system_;
 }
 
 const std::string& CdmSessionAdapter::GetKeySystemUMAPrefix() const {
   DCHECK(!key_system_uma_prefix_.empty());
   return key_system_uma_prefix_;
 }
 
 void CdmSessionAdapter::OnCdmCreated(
     const std::string& key_system,
     base::TimeTicks start_time,
     const scoped_refptr<ContentDecryptionModule>& cdm,
     const std::string& error_message) {
-  DVLOG(2) << __func__ << ": "
+  DVLOG(1) << __func__ << ": "
            << (cdm ? "success" : "failure (" + error_message + ")");
   DCHECK(!cdm_);
 
   TRACE_EVENT_ASYNC_END2("media", "CdmSessionAdapter::CreateCdm", trace_id_,
                          "success", (cdm ? "true" : "false"), "error_message",
                          error_message);
 
   if (!cdm) {
     cdm_created_result_->completeWithError(
         blink::WebContentDecryptionModuleExceptionNotSupportedError, 0,
@@ skipping 16 matching lines @@
   cdm_created_result_.reset();
 }
 
 void CdmSessionAdapter::OnSessionMessage(
     const std::string& session_id,
     ContentDecryptionModule::MessageType message_type,
     const std::vector<uint8_t>& message) {
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __func__ << " for unknown session "
                              << session_id;
-  if (session)
+  if (session) {
+    DVLOG(3) << __func__ << ": session_id = " << session_id;
     session->OnSessionMessage(message_type, message);
+  }
 }
 
 void CdmSessionAdapter::OnSessionKeysChange(const std::string& session_id,
                                             bool has_additional_usable_key,
                                             CdmKeysInfo keys_info) {
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __func__ << " for unknown session "
                              << session_id;
-  if (session)
+  if (session) {
+    DVLOG(2) << __func__ << ": session_id = " << session_id;
+    DVLOG(2) << "  - has_additional_usable_key = " << has_additional_usable_key;
+    for (const CdmKeyInformation* info : keys_info)
+      DVLOG(2) << "  - " << *info;
+
     session->OnSessionKeysChange(has_additional_usable_key,
                                  std::move(keys_info));
+  }
 }
 
 void CdmSessionAdapter::OnSessionExpirationUpdate(const std::string& session_id,
                                                   base::Time new_expiry_time) {
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __func__ << " for unknown session "
                              << session_id;
-  if (session)
+  if (session) {
+    DVLOG(2) << __func__ << ": session_id = " << session_id;
+    if (new_expiry_time.is_null())
+      DVLOG(2) << "  - new_expiry_time = NaN";
+    else
+      DVLOG(2) << "  - new_expiry_time = " << new_expiry_time;
+
     session->OnSessionExpirationUpdate(new_expiry_time);
+  }
 }
 
 void CdmSessionAdapter::OnSessionClosed(const std::string& session_id) {
   WebContentDecryptionModuleSessionImpl* session = GetSession(session_id);
   DLOG_IF(WARNING, !session) << __func__ << " for unknown session "
                              << session_id;
-  if (session)
+  if (session) {
+    DVLOG(2) << __func__ << ": session_id = " << session_id;
     session->OnSessionClosed();
+  }
 }
 
 WebContentDecryptionModuleSessionImpl* CdmSessionAdapter::GetSession(
     const std::string& session_id) {
   // Since session objects may get garbage collected, it is possible that there
   // are events coming back from the CDM and the session has been unregistered.
   // We can not tell if the CDM is firing events at sessions that never existed.
   SessionMap::iterator session = sessions_.find(session_id);
   return (session != sessions_.end()) ? session->second.get() : NULL;
 }
 
 void CdmSessionAdapter::ReportTimeToCreateCdmUMA(base::TimeDelta time) const {
   // Note: This leaks memory, which is expected behavior.
   base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
       GetKeySystemUMAPrefix() + kTimeToCreateCdmUMAName,
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromSeconds(10),
       50, base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram->AddTime(time);
 }
 
 }  // namespace media