Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/formats/webm/webm_stream_parser_unittest.cc

 // Copyright 2016 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/formats/webm/webm_stream_parser.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mock_media_log.h"
 #include "media/base/stream_parser.h"
 #include "media/base/test_data_util.h"
 #include "media/base/text_track_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::SaveArg;
 using testing::_;
 
 namespace media {
 
 class WebMStreamParserTest : public testing::Test {
  public:
-  WebMStreamParserTest()
-      : media_log_(new testing::StrictMock<MockMediaLog>()) {}
+  WebMStreamParserTest() {}
 
  protected:
   void ParseWebMFile(const std::string& filename,
                      const StreamParser::InitParameters& expected_params) {
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     parser_.reset(new WebMStreamParser());
     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb =
         base::Bind(&WebMStreamParserTest::OnEncryptedMediaInitData,
                    base::Unretained(this));
 
     EXPECT_CALL(*this, InitCB(_));
     EXPECT_CALL(*this, NewMediaSegmentCB()).Times(testing::AnyNumber());
     EXPECT_CALL(*this, EndMediaSegmentCB()).Times(testing::AnyNumber());
     EXPECT_CALL(*this, NewBuffersCB(_))
         .Times(testing::AnyNumber())
         .WillRepeatedly(testing::Return(true));
     parser_->Init(
         base::Bind(&WebMStreamParserTest::InitF, base::Unretained(this),
                    expected_params),
         base::Bind(&WebMStreamParserTest::NewConfigCB, base::Unretained(this)),
         base::Bind(&WebMStreamParserTest::NewBuffersCB, base::Unretained(this)),
         false,  // don't ignore_text_track
         encrypted_media_init_data_cb,
         base::Bind(&WebMStreamParserTest::NewMediaSegmentCB,
                    base::Unretained(this)),
         base::Bind(&WebMStreamParserTest::EndMediaSegmentCB,
                    base::Unretained(this)),
-        media_log_);
+        &media_log_);
     bool result = parser_->Parse(buffer->data(), buffer->data_size());
     EXPECT_TRUE(result);
   }
 
   // Verifies only the detected track counts by track type, then chains to the
   // InitCB mock.
   void InitF(const StreamParser::InitParameters& expected_params,
              const StreamParser::InitParameters& params) {
     EXPECT_EQ(expected_params.detected_audio_track_count,
               params.detected_audio_track_count);
@@ skipping 13 matching lines @@
     return true;
   }
 
   MOCK_METHOD1(NewBuffersCB, bool(const StreamParser::BufferQueueMap&));
   MOCK_METHOD2(OnEncryptedMediaInitData,
                void(EmeInitDataType init_data_type,
                     const std::vector<uint8_t>& init_data));
   MOCK_METHOD0(NewMediaSegmentCB, void());
   MOCK_METHOD0(EndMediaSegmentCB, void());
 
-  scoped_refptr<testing::StrictMock<MockMediaLog>> media_log_;
+  testing::StrictMock<MockMediaLog> media_log_;
   std::unique_ptr<WebMStreamParser> parser_;
   std::unique_ptr<MediaTracks> media_tracks_;
 };
 
 TEST_F(WebMStreamParserTest, VerifyMediaTrackMetadata) {
   EXPECT_MEDIA_LOG(testing::HasSubstr("Estimating WebM block duration"))
       .Times(testing::AnyNumber());
   StreamParser::InitParameters params(kInfiniteDuration);
   params.detected_audio_track_count = 1;
   params.detected_video_track_count = 1;
@@ skipping 87 matching lines @@
   EXPECT_FLOAT_EQ(mmdata.primary_g.y(), 0.2f);
   EXPECT_FLOAT_EQ(mmdata.primary_b.x(), 0.1f);
   EXPECT_FLOAT_EQ(mmdata.primary_b.y(), 0.2f);
   EXPECT_FLOAT_EQ(mmdata.white_point.x(), 0.1f);
   EXPECT_FLOAT_EQ(mmdata.white_point.y(), 0.2f);
   EXPECT_EQ(mmdata.luminance_max, 40);
   EXPECT_EQ(mmdata.luminance_min, 30);
 }
 
 }  // namespace media