Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/blink/watch_time_reporter_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 <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/run_loop.h"
 #include "base/test/test_message_loop.h"
 #include "media/base/mock_media_log.h"
 #include "media/blink/watch_time_reporter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 constexpr gfx::Size kSizeJustRight = gfx::Size(201, 201);
 
 #define EXPECT_WATCH_TIME(key, value)                                      \
   do {                                                                     \
     EXPECT_CALL(                                                           \
-        *media_log_,                                                       \
+        media_log_,                                                        \
         OnWatchTimeUpdate(has_video_ ? MediaLog::kWatchTimeAudioVideo##key \
                                      : MediaLog::kWatchTimeAudio##key,     \
                           value))                                          \
         .RetiresOnSaturation();                                            \
   } while (0)
 
 #define EXPECT_BACKGROUND_WATCH_TIME(key, value)                           \
   do {                                                                     \
     DCHECK(has_video_);                                                    \
-    EXPECT_CALL(*media_log_,                                               \
+    EXPECT_CALL(media_log_,                                                \
                 OnWatchTimeUpdate(                                         \
                     MediaLog::kWatchTimeAudioVideoBackground##key, value)) \
         .RetiresOnSaturation();                                            \
   } while (0)
 
 #define EXPECT_WATCH_TIME_FINALIZED() \
-  EXPECT_CALL(*media_log_, OnWatchTimeFinalized()).RetiresOnSaturation();
+  EXPECT_CALL(media_log_, OnWatchTimeFinalized()).RetiresOnSaturation();
 
 #define EXPECT_POWER_WATCH_TIME_FINALIZED() \
-  EXPECT_CALL(*media_log_, OnPowerWatchTimeFinalized()).RetiresOnSaturation();
+  EXPECT_CALL(media_log_, OnPowerWatchTimeFinalized()).RetiresOnSaturation();
 
 class WatchTimeReporterTest : public testing::TestWithParam<bool> {
  public:
-  WatchTimeReporterTest()
-      : has_video_(GetParam()),
-        media_log_(new testing::StrictMock<WatchTimeLogMonitor>()) {}
+  WatchTimeReporterTest() : has_video_(GetParam()) {}
   ~WatchTimeReporterTest() override {}
 
  protected:
   class WatchTimeLogMonitor : public MediaLog {
    public:
     WatchTimeLogMonitor() {}
 
     void AddEvent(std::unique_ptr<MediaLogEvent> event) override {
       ASSERT_EQ(event->type, MediaLogEvent::Type::WATCH_TIME_UPDATE);
 
@@ skipping 26 matching lines @@
   };
 
   void Initialize(bool has_audio,
                   bool is_mse,
                   bool is_encrypted,
                   const gfx::Size& initial_video_size) {
     if (wtr_ && IsMonitoring())
       EXPECT_WATCH_TIME_FINALIZED();
 
     wtr_.reset(new WatchTimeReporter(
-        has_audio, has_video_, is_mse, is_encrypted, false, media_log_,
+        has_audio, has_video_, is_mse, is_encrypted, false, &media_log_,
         initial_video_size,
         base::Bind(&WatchTimeReporterTest::GetCurrentMediaTime,
                    base::Unretained(this))));
 
     // Setup the reporting interval to be immediate to avoid spinning real time
     // within the unit test.
     wtr_->reporting_interval_ = base::TimeDelta();
     if (wtr_->background_reporter_)
       wtr_->background_reporter_->reporting_interval_ = base::TimeDelta();
   }
@@ skipping 149 matching lines @@
       EXPECT_WATCH_TIME(Ac, kWatchTime4 - kWatchTime2);
     else
       EXPECT_WATCH_TIME(Battery, kWatchTime4 - kWatchTime2);
     EXPECT_WATCH_TIME_FINALIZED();
     wtr_.reset();
   }
 
   MOCK_METHOD0(GetCurrentMediaTime, base::TimeDelta());
 
   const bool has_video_;
+  testing::StrictMock<WatchTimeLogMonitor> media_log_;
   base::TestMessageLoop message_loop_;
-  scoped_refptr<testing::StrictMock<WatchTimeLogMonitor>> media_log_;
   std::unique_ptr<WatchTimeReporter> wtr_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WatchTimeReporterTest);
 };
 
 // Tests that watch time reporting is appropriately enabled or disabled.
 TEST_P(WatchTimeReporterTest, WatchTimeReporter) {
   EXPECT_CALL(*this, GetCurrentMediaTime())
       .WillRepeatedly(testing::Return(base::TimeDelta()));
@@ skipping 551 matching lines @@
           });
     }
   }
 }
 
 INSTANTIATE_TEST_CASE_P(WatchTimeReporterTest,
                         WatchTimeReporterTest,
                         testing::Values(true, false));
 
 }  // namespace media