Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/html/AutoplayExperimentTest.cpp

 // Copyright 2015 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 "core/dom/Document.h"
 #include "core/html/AutoplayExperimentHelper.h"
 #include "platform/UserGestureIndicator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 86 matching lines @@
 public:
     AutoplayExperimentTest() {}
 
     ~AutoplayExperimentTest() {}
 
     bool isEligible()
     {
         return m_helper->isEligible();
     }
 
-    void setInterface(PassOwnPtrWillBeRawPtr<MockAutoplayClient> client)
+    void setInterface(RawPtr<MockAutoplayClient> client)
     {
         m_client = client;
 
         // Set some defaults.
         setUserGestureRequiredForPlay(true);
         setShouldAutoplay(true);
         setIsMuted(false);
 
         m_helper = AutoplayExperimentHelper::create(m_client.get());
     }
 
 #if ENABLE(OILPAN)
     void TearDown()
     {
         // Be sure that the mock is destructed before the test, so that any
         // missing expectations are noticed.  Otherwise, the test will pass
         // and then missing expectations will show up in the log, without
         // causing a test failure.
         m_helper.clear();
         m_client.clear();
         Heap::collectAllGarbage();
     }
 #endif
 
-    OwnPtrWillBePersistent<MockAutoplayClient> m_client;
-    OwnPtrWillBePersistent<AutoplayExperimentHelper> m_helper;
+    Persistent<MockAutoplayClient> m_client;
+    Persistent<AutoplayExperimentHelper> m_helper;
 
     // Mirror updatePlayState to transition to play.
     void startPlayback()
     {
         EXPECT_CALL(*m_client, recordAutoplayMetric(AnyPlaybackStarted))
             .Times(1);
         m_helper->playbackStarted();
     }
 
     void startPlaybackWithoutUserGesture()
@@ skipping 76 matching lines @@
 
     void moveIntoViewport()
     {
         m_helper->positionChanged(IntRect(0, 0, 200, 200));
         m_helper->triggerAutoplayViewportCheckForTesting();
     }
 };
 
 TEST_F(AutoplayExperimentTest, IsNotEligibleWithEmptyMode)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("", MockAutoplayClient::Video));
     EXPECT_FALSE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, IsVideoEligibleForVideoMode)
 {
     // Video should be eligible in "forvideo" mode.
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
     EXPECT_TRUE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, IsAudioNotEligibleForVideoMode)
 {
     // Audio should not be eligible for video mode.
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Audio)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Audio));
     EXPECT_FALSE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, IsEligibleRequiresUserGesture)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
     // If a user gesture is not required, then we're not eligible.
     ON_CALL(*m_client, isUserGestureRequiredForPlay())
         .WillByDefault(Return(false));
     EXPECT_FALSE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, IsEligibleRequiresShouldAutoplay)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
     // If we shouldn't autoplay, then we're not eligible.
     ON_CALL(*m_client, shouldAutoplay())
         .WillByDefault(Return(false));
     EXPECT_FALSE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, IsAudioEligibleForAudioMode)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-foraudio", MockAutoplayClient::Audio)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-foraudio", MockAutoplayClient::Audio));
     EXPECT_TRUE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, EligibleIfOptimizedForMobile)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifmobile", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifmobile", MockAutoplayClient::Video));
     // Should not be eligible with our default of "not mobile".
     EXPECT_FALSE(isEligible());
 
     ON_CALL(*m_client, isLegacyViewportType())
         .WillByDefault(Return(true));
     EXPECT_TRUE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, EligibleIfMuted)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifmuted", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifmuted", MockAutoplayClient::Video));
     // Should not be eligible with our default of "not muted".
     EXPECT_FALSE(isEligible());
 
     ON_CALL(*m_client, muted())
         .WillByDefault(Return(true));
     EXPECT_TRUE(isEligible());
 }
 
 TEST_F(AutoplayExperimentTest, BecameReadyAutoplayThenBailout)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
 
     EXPECT_CALL(*m_client, removeUserGestureRequirement())
         .Times(1);
     EXPECT_CALL(*m_client, recordAutoplayMetric(AutoplayMediaFound))
         .Times(1);
     m_helper->becameReadyToPlay();
 
     EXPECT_CALL(*m_client, recordAutoplayMetric(GesturelessPlaybackStartedByAutoplayFlagImmediately))
         .Times(1);
     startPlaybackWithoutUserGesture();
 
     pausePlaybackExpectingBailout(true);
 }
 
 TEST_F(AutoplayExperimentTest, BecameReadyAutoplayThenPause)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
 
     EXPECT_CALL(*m_client, removeUserGestureRequirement())
         .Times(1);
     EXPECT_CALL(*m_client, recordAutoplayMetric(AutoplayMediaFound))
         .Times(1);
     m_helper->becameReadyToPlay();
 
     EXPECT_CALL(*m_client, recordAutoplayMetric(GesturelessPlaybackStartedByAutoplayFlagImmediately))
         .Times(1);
     startPlaybackWithoutUserGesture();
 
     pausePlaybackNotExpectingBailout(true);
 }
 
 TEST_F(AutoplayExperimentTest, BecameReadyAutoplayThenComplete)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
 
     EXPECT_CALL(*m_client, removeUserGestureRequirement())
         .Times(1);
     EXPECT_CALL(*m_client, recordAutoplayMetric(AutoplayMediaFound))
         .Times(1);
     m_helper->becameReadyToPlay();
 
     EXPECT_CALL(*m_client, recordAutoplayMetric(GesturelessPlaybackStartedByAutoplayFlagImmediately))
         .Times(1);
     startPlaybackWithoutUserGesture();
 
     // Now stop at the end.
     endPlayback(true);
 }
 
 TEST_F(AutoplayExperimentTest, NoUserGestureNeededShouldNotOverride)
 {
     // Make sure that we don't override the user gesture if it isn't needed.
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
     setUserGestureRequiredForPlay(false);
 
     // It is still autoplay media, though.
     EXPECT_CALL(*m_client, recordAutoplayMetric(AutoplayMediaFound))
         .Times(1);
     m_helper->becameReadyToPlay();
 
     EXPECT_CALL(*m_client, recordAutoplayMetric(GesturelessPlaybackNotOverridden))
         .Times(1);
     startPlaybackWithoutUserGesture();
 }
 
 TEST_F(AutoplayExperimentTest, NoAutoplayMetricsIfNoAutoplay)
 {
     // If playback is started while processing a user gesture, then nothing
     // should be overridden or logged about autoplay.
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
     setUserGestureRequiredForPlay(false);
     setShouldAutoplay(false);
     startPlaybackWithUserGesture();
 
     // Expect bailout, but not from autoplay.
     pausePlaybackExpectingBailout(false);
 }
 
 TEST_F(AutoplayExperimentTest, PlayMethodThenBailout)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo", MockAutoplayClient::Video));
     setShouldAutoplay(false); // No autoplay attribute.
 
     EXPECT_CALL(*m_client, removeUserGestureRequirement())
         .Times(1);
     EXPECT_CALL(*m_client, recordAutoplayMetric(AutoplayMediaFound))
         .Times(1);
     m_helper->playMethodCalled();
 
     EXPECT_CALL(*m_client, recordAutoplayMetric(GesturelessPlaybackStartedByPlayMethodImmediately))
         .Times(1);
     startPlaybackWithoutUserGesture();
 
     pausePlaybackExpectingBailout(true);
 }
 
 TEST_F(AutoplayExperimentTest, DeferAutoplayUntilMuted)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifmuted", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifmuted", MockAutoplayClient::Video));
 
     // Should not override the gesture requirement yet.
     EXPECT_CALL(*m_client, recordAutoplayMetric(AutoplayMediaFound))
         .Times(1);
     m_helper->becameReadyToPlay();
 
     // When we toggle the muted attribute, it should start.
     EXPECT_CALL(*m_client, removeUserGestureRequirement())
         .Times(1);
     EXPECT_CALL(*m_client, playInternal())
         .Times(1);
     setIsMuted(true);
     m_helper->mutedChanged();
 
     // When playback starts (in response to playInternal()), it should also
     // record why.  'After scroll' isn't the best name, but this isn't a common case.
     EXPECT_CALL(*m_client, recordAutoplayMetric(GesturelessPlaybackStartedByAutoplayFlagAfterScroll))
         .Times(1);
     startPlaybackWithoutUserGesture();
 }
 
 TEST_F(AutoplayExperimentTest, DeferPlaybackUntilInViewport)
 {
-    setInterface(adoptPtrWillBeNoop(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifviewport", MockAutoplayClient::Video)));
+    setInterface(new NiceMock<MockAutoplayClient>("enabled-forvideo-ifviewport", MockAutoplayClient::Video));
 
     // Should not override the gesture requirement yet.
     EXPECT_CALL(*m_client, recordAutoplayMetric(AutoplayMediaFound))
         .Times(1);
     EXPECT_CALL(*m_client, setRequestPositionUpdates(true))
         .Times(1);
     m_helper->becameReadyToPlay();
 
     EXPECT_CALL(*m_client, removeUserGestureRequirement())
         .Times(1);
     EXPECT_CALL(*m_client, playInternal())
         .Times(1);
     EXPECT_CALL(*m_client, setRequestPositionUpdates(false))
         .Times(1);
     moveIntoViewport();
 }
 }