Add unit tests for CdmAdapter

media/cdm/ppapi/external_clear_key/clear_key_cdm.cc

 // Copyright 2013 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/cdm/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 
@@ skipping 194 matching lines @@
   for (const auto& key_info : keys_info) {
     cdm::KeyInformation key;
     key.key_id = vector_as_array(&key_info->key_id);
     key.key_id_size = key_info->key_id.size();
     key.status = ConvertKeyStatus(key_info->status);
     key.system_code = key_info->system_code;
     keys_vector->push_back(key);
   }
 }
 
-template<typename Type>
-class ScopedResetter {
- public:
-  explicit ScopedResetter(Type* object) : object_(object) {}
-  ~ScopedResetter() { object_->Reset(); }
-
- private:
-  Type* const object_;
-};
+// If GURL::EmptyGURL() is used then a static object is created, and
+// never freed. This means the LeakSanitizer will complain that that
+// an object is never freed. Creating our own copy, which also verifies
+// that DeinitializeCdmModule() is called.
+static GURL* empty_gurl;
 
 void INITIALIZE_CDM_MODULE() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(!empty_gurl) << "Only call INITIALIZE_CDM_MODULE() once.";
+
+  empty_gurl = new GURL();
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   av_register_all();
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 void DeinitializeCdmModule() {
+  DVLOG(1) << __FUNCTION__;
+  delete empty_gurl;
 }
 
 void* CreateCdmInstance(int cdm_interface_version,
                         const char* key_system, uint32_t key_system_size,
                         GetCdmHostFunc get_cdm_host_func,
                         void* user_data) {
   DVLOG(1) << "CreateCdmInstance()";
 
   std::string key_system_string(key_system, key_system_size);
   if (key_system_string != kExternalClearKeyKeySystem &&
       key_system_string != kExternalClearKeyDecryptOnlyKeySystem &&
       key_system_string != kExternalClearKeyFileIOTestKeySystem &&
       key_system_string != kExternalClearKeyCrashKeySystem) {
     DVLOG(1) << "Unsupported key system:" << key_system_string;
     return NULL;
   }
 
   if (cdm_interface_version != media::ClearKeyCdmInterface::kVersion)
     return NULL;
 
   media::ClearKeyCdmHost* host = static_cast<media::ClearKeyCdmHost*>(
       get_cdm_host_func(media::ClearKeyCdmHost::kVersion, user_data));
   if (!host)
     return NULL;
 
   // TODO(jrummell): Obtain the proper origin for this instance.
-  return new media::ClearKeyCdm(host, key_system_string, GURL::EmptyGURL());
+  return new media::ClearKeyCdm(host, key_system_string, *empty_gurl);

[xhwang, 2015/11/13 00:03:22]

Can we just create a temp local GURL here instead of using a global one?

[jrummell, 2015/11/13 00:35:20]

Done.

 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace media {
 
 ClearKeyCdm::ClearKeyCdm(ClearKeyCdmHost* host,
                          const std::string& key_system,
@@ skipping 640 matching lines @@
 void ClearKeyCdm::OnFileIOTestComplete(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   std::string message = GetFileIOTestResultMessage(success);
   host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
                           cdm::kLicenseRequest, message.data(),
                           message.length(), NULL, 0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media