Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/filters/audio_decoder_selector_unittest.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 <stddef.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 34 matching lines @@
 class AudioDecoderSelectorTest : public ::testing::Test {
  public:
   enum DecryptorCapability {
     kNoCdm,        // No CDM. Only possible for clear stream.
     kNoDecryptor,  // CDM is available but Decryptor is not supported.
     kDecryptOnly,
     kDecryptAndDecode
   };
 
   AudioDecoderSelectorTest()
-      : media_log_(new MediaLog()),
-        traits_(media_log_),
+      : traits_(&media_log_),
         demuxer_stream_(
             new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
         decoder_1_(new StrictMock<MockAudioDecoder>()),
         decoder_2_(new StrictMock<MockAudioDecoder>()) {
     all_decoders_.push_back(decoder_1_);
     all_decoders_.push_back(decoder_2_);
     // |cdm_context_| and |decryptor_| are conditionally created in
     // InitializeDecoderSelector().
   }
 
@@ skipping 38 matching lines @@
             .WillRepeatedly(
                 RunCallback<1>(decryptor_capability == kDecryptAndDecode));
       }
     }
 
     DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders));
     all_decoders_.erase(
         all_decoders_.begin() + num_decoders, all_decoders_.end());
 
     decoder_selector_.reset(new AudioDecoderSelector(
-        message_loop_.task_runner(), std::move(all_decoders_), media_log_));
+        message_loop_.task_runner(), std::move(all_decoders_), &media_log_));
   }
 
   void SelectDecoder() {
     decoder_selector_->SelectDecoder(
         &traits_, demuxer_stream_.get(), cdm_context_.get(),
         base::Bind(&AudioDecoderSelectorTest::MockOnDecoderSelected,
                    base::Unretained(this)),
         base::Bind(&AudioDecoderSelectorTest::OnDecoderOutput),
         base::Bind(&AudioDecoderSelectorTest::OnWaitingForDecryptionKey));
     base::RunLoop().RunUntilIdle();
   }
 
   void SelectDecoderAndDestroy() {
     SelectDecoder();
 
     EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
     decoder_selector_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   static void OnDecoderOutput(const scoped_refptr<AudioBuffer>& output) {
     NOTREACHED();
   }
 
   static void OnWaitingForDecryptionKey() {
     NOTREACHED();
   }
 
-  scoped_refptr<MediaLog> media_log_;
+  MediaLog media_log_;
 
   // Stream traits specific to audio decoding.
   DecoderStreamTraits<DemuxerStream::AUDIO> traits_;
 
   // Declare |decoder_selector_| after |demuxer_stream_| and |decryptor_| since
   // |demuxer_stream_| and |decryptor_| should outlive |decoder_selector_|.
   std::unique_ptr<StrictMock<MockDemuxerStream>> demuxer_stream_;
 
   std::unique_ptr<StrictMock<MockCdmContext>> cdm_context_;
 
@@ skipping 274 matching lines @@
   // initialized and returned.
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull()));
 #endif
 
   SelectDecoder();
 }
 
 }  // namespace media