Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/filters/video_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 32 matching lines @@
 class VideoDecoderSelectorTest : 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
   };
 
   VideoDecoderSelectorTest()
-      : media_log_(new MediaLog()),
-        traits_(media_log_),
+      : traits_(&media_log_),
         demuxer_stream_(
             new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         decoder_1_(new StrictMock<MockVideoDecoder>()),
         decoder_2_(new StrictMock<MockVideoDecoder>()) {
     all_decoders_.push_back(decoder_1_);
     all_decoders_.push_back(decoder_2_);
     // |cdm_context_| and |decryptor_| are conditionally created in
     // InitializeDecoderSelector().
   }
 
@@ skipping 33 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 VideoDecoderSelector(
-        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(&VideoDecoderSelectorTest::MockOnDecoderSelected,
                    base::Unretained(this)),
         base::Bind(&VideoDecoderSelectorTest::FrameReady,
                    base::Unretained(this)),
         base::Bind(&VideoDecoderSelectorTest::OnWaitingForDecryptionKey,
@@ skipping 10 matching lines @@
   }
 
   void FrameReady(const scoped_refptr<VideoFrame>& frame) {
     NOTREACHED();
   }
 
   void OnWaitingForDecryptionKey() {
     NOTREACHED();
   }
 
-  scoped_refptr<MediaLog> media_log_;
+  MediaLog media_log_;
 
   // Stream traits specific to video decoding.
   DecoderStreamTraits<DemuxerStream::VIDEO> 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 276 matching lines @@
   // initialized and returned.
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
       .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull()));
 #endif
 
   SelectDecoder();
 }
 
 }  // namespace media