media: Make MediaKeys ref-counted.

media/test/pipeline_integration_test.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"

[jrummell, 2015/10/29 21:05:17]

#include "base/memory/ref_counted.h"?

[xhwang, 2015/10/30 16:20:59]

Done.

 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_context.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media.h"
 #include "media/base/media_keys.h"
@@ skipping 177 matching lines @@
                                       const std::string& error_message) {
       FAIL() << "Unexpected Key Error";
     }
 
     virtual void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                           const std::vector<uint8_t>& init_data,
                                           AesDecryptor* decryptor) = 0;
   };
 
   FakeEncryptedMedia(AppBase* app)
-      : decryptor_(GURL::EmptyGURL(),
-                   base::Bind(&FakeEncryptedMedia::OnSessionMessage,
-                              base::Unretained(this)),
-                   base::Bind(&FakeEncryptedMedia::OnSessionClosed,
-                              base::Unretained(this)),
-                   base::Bind(&FakeEncryptedMedia::OnSessionKeysChange,
-                              base::Unretained(this))),
-        cdm_context_(&decryptor_),
+      : decryptor_(new AesDecryptor(
+            GURL::EmptyGURL(),
+            base::Bind(&FakeEncryptedMedia::OnSessionMessage,
+                       base::Unretained(this)),
+            base::Bind(&FakeEncryptedMedia::OnSessionClosed,
+                       base::Unretained(this)),
+            base::Bind(&FakeEncryptedMedia::OnSessionKeysChange,
+                       base::Unretained(this)))),
+        cdm_context_(decryptor_.get()),
         app_(app) {}
 
   CdmContext* GetCdmContext() { return &cdm_context_; }
 
   // Callbacks for firing session events. Delegate to |app_|.
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
                         const std::vector<uint8_t>& message,
                         const GURL& legacy_destination_url) {
     app_->OnSessionMessage(session_id, message_type, message,
-                           legacy_destination_url, &decryptor_);
+                           legacy_destination_url, decryptor_.get());
   }
 
   void OnSessionClosed(const std::string& session_id) {
     app_->OnSessionClosed(session_id);
   }
 
   void OnSessionKeysChange(const std::string& session_id,
                            bool has_additional_usable_key,
                            CdmKeysInfo keys_info) {
     app_->OnSessionKeysChange(session_id, has_additional_usable_key,
                               keys_info.Pass());
   }
 
   void OnLegacySessionError(const std::string& session_id,
                             const std::string& error_name,
                             uint32_t system_code,
                             const std::string& error_message) {
     app_->OnLegacySessionError(session_id, error_name, system_code,
                                error_message);
   }
 
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data) {
-    app_->OnEncryptedMediaInitData(init_data_type, init_data, &decryptor_);
+    app_->OnEncryptedMediaInitData(init_data_type, init_data, decryptor_.get());
   }
 
  private:
   class TestCdmContext : public CdmContext {
    public:
     TestCdmContext(Decryptor* decryptor) : decryptor_(decryptor) {}
 
     Decryptor* GetDecryptor() final { return decryptor_; }
     int GetCdmId() const final { return kInvalidCdmId; }
 
    private:
     Decryptor* decryptor_;
   };
 
-  AesDecryptor decryptor_;
+  scoped_refptr<AesDecryptor> decryptor_;
   TestCdmContext cdm_context_;
   scoped_ptr<AppBase> app_;
 };
 
 enum PromiseResult { RESOLVED, REJECTED };
 
 // Provides |kSecretKey| in response to needkey.
 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
  public:
   KeyProvidingApp() {}
@@ skipping 1566 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media