[Media] Add a finch trial param for background MediaSource videos

media/blink/webmediaplayer_impl_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/blink/webmediaplayer_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 10 matching lines @@
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_helpers.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_params.h"
 #include "media/renderers/default_renderer_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "url/gurl.h"
 
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::_;
 
 namespace media {
 
+// Specify different values for testing.
+const base::TimeDelta kMaxKeyframeDistanceToDisableBackgroundVideo =
+    base::TimeDelta::FromSeconds(5);
+const base::TimeDelta kMaxKeyframeDistanceToDisableBackgroundVideoMSE =
+    base::TimeDelta::FromSeconds(10);
+
 int64_t OnAdjustAllocatedMemory(int64_t delta) {
   return 0;
 }
 
 class DummyWebMediaPlayerClient : public blink::WebMediaPlayerClient {
  public:
   DummyWebMediaPlayerClient() {}
 
   // blink::WebMediaPlayerClient implementation.
   void NetworkStateChanged() override {}
@@ skipping 151 matching lines @@
         web_local_frame_, &client_, nullptr, &delegate_,
         base::MakeUnique<DefaultRendererFactory>(
             media_log_, nullptr, DefaultRendererFactory::GetGpuFactoriesCB()),
         url_index_,
         WebMediaPlayerParams(
             WebMediaPlayerParams::DeferLoadCB(),
             scoped_refptr<SwitchableAudioRendererSink>(), media_log_,
             media_thread_.task_runner(), message_loop_.task_runner(),
             message_loop_.task_runner(), WebMediaPlayerParams::Context3DCB(),
             base::Bind(&OnAdjustAllocatedMemory), nullptr, nullptr, nullptr,
-            base::TimeDelta::FromSeconds(10), false, allow_suspend, false));
+            kMaxKeyframeDistanceToDisableBackgroundVideo,
+            kMaxKeyframeDistanceToDisableBackgroundVideoMSE, false,
+            allow_suspend, false));
   }
 
   ~WebMediaPlayerImplTest() override {
     // Destruct WebMediaPlayerImpl and pump the message loop to ensure that
     // objects passed to the message loop for destruction are released.
     //
     // NOTE: This should be done before any other member variables are
     // destructed since WMPI may reference them during destruction.
     wmpi_.reset();
     base::RunLoop().RunUntilIdle();
@@ skipping 95 matching lines @@
   void ScheduleIdlePauseTimer() { wmpi_->ScheduleIdlePauseTimer(); }
 
   bool IsIdlePauseTimerRunning() {
     return wmpi_->background_pause_timer_.IsRunning();
   }
 
   void SetSuspendState(bool is_suspended) {
     wmpi_->SetSuspendState(is_suspended);
   }
 
+  void SetLoadType(blink::WebMediaPlayer::LoadType load_type) {
+    wmpi_->load_type_ = load_type;
+  }
+
   // "Renderer" thread.
   base::MessageLoop message_loop_;
 
   // "Media" thread. This is necessary because WMPI destruction waits on a
   // WaitableEvent.
   base::Thread media_thread_;
 
   // Blink state.
   blink::WebFrameClient web_frame_client_;
   blink::WebView* web_view_;
@@ skipping 445 matching lines @@
   EXPECT_FALSE(IsIdlePauseTimerRunning());
 
   SetMetadata(true, true);
   ScheduleIdlePauseTimer();
   EXPECT_TRUE(IsIdlePauseTimerRunning());
 }
 
 class WebMediaPlayerImplBackgroundBehaviorTest
     : public WebMediaPlayerImplTest,
       public ::testing::WithParamInterface<
-          std::tuple<bool, bool, int, int, bool>> {
+          std::tuple<bool, bool, int, int, bool, bool>> {
  public:
   // Indices of the tuple parameters.
   static const int kIsMediaSuspendEnabled = 0;
   static const int kIsBackgroundOptimizationEnabled = 1;
   static const int kDurationSec = 2;
   static const int kAverageKeyframeDistanceSec = 3;
   static const int kIsResumeBackgroundVideoEnabled = 4;
+  static const int kIsMediaSource = 5;
 
   void SetUp() override {
     WebMediaPlayerImplTest::SetUp();
 
     SetUpMediaSuspend(IsMediaSuspendOn());
 
     std::string enabled_features;
     std::string disabled_features;
     if (IsBackgroundOptimizationOn()) {
       enabled_features += kBackgroundVideoTrackOptimization.name;
     } else {
       disabled_features += kBackgroundVideoTrackOptimization.name;
     }
 
     if (IsResumeBackgroundVideoEnabled()) {
       if (!enabled_features.empty())
         enabled_features += ",";
       enabled_features += kResumeBackgroundVideo.name;
     } else {
       if (!disabled_features.empty())
         disabled_features += ",";
       disabled_features += kResumeBackgroundVideo.name;
     }
 
     feature_list_.InitFromCommandLine(enabled_features, disabled_features);
 
     InitializeWebMediaPlayerImpl(true);
+    bool is_media_source = std::get<kIsMediaSource>(GetParam());
+    SetLoadType(is_media_source ? blink::WebMediaPlayer::kLoadTypeMediaSource
+                                : blink::WebMediaPlayer::kLoadTypeURL);
     SetVideoKeyframeDistanceAverage(
         base::TimeDelta::FromSeconds(GetAverageKeyframeDistanceSec()));
     SetDuration(base::TimeDelta::FromSeconds(GetDurationSec()));
     BackgroundPlayer();
   }
 
   void SetDuration(base::TimeDelta value) {
     wmpi_->SetPipelineMediaDurationForTest(value);
   }
 
@@ skipping 14 matching lines @@
   bool IsResumeBackgroundVideoEnabled() {
     return std::get<kIsResumeBackgroundVideoEnabled>(GetParam());
   }
 
   int GetDurationSec() const { return std::get<kDurationSec>(GetParam()); }
 
   int GetAverageKeyframeDistanceSec() const {
     return std::get<kAverageKeyframeDistanceSec>(GetParam());
   }
 
+  int GetMaxKeyframeDistanceSec() const {
+    base::TimeDelta max_keyframe_distance =
+        std::get<kIsMediaSource>(GetParam())
+            ? kMaxKeyframeDistanceToDisableBackgroundVideoMSE
+            : kMaxKeyframeDistanceToDisableBackgroundVideo;
+    return max_keyframe_distance.InSeconds();
+  }
+
   bool IsAndroid() {
 #if defined(OS_ANDROID)
     return true;
 #else
     return false;
 #endif
   }
 
   bool ShouldDisableVideoWhenHidden() const {
     return wmpi_->ShouldDisableVideoWhenHidden();
@@ skipping 22 matching lines @@
 TEST_P(WebMediaPlayerImplBackgroundBehaviorTest, VideoOnly) {
   // Video only.
   SetMetadata(false, true);
 
   // Never disable video track for a video only stream.
   EXPECT_FALSE(ShouldDisableVideoWhenHidden());
 
   // There's no optimization criteria for video only on Android.
   bool matches_requirements =
       IsAndroid() ||
-      ((GetDurationSec() < GetAverageKeyframeDistanceSec()) ||
-       (GetAverageKeyframeDistanceSec() < 10));
+      ((GetDurationSec() < GetMaxKeyframeDistanceSec()) ||
+       (GetAverageKeyframeDistanceSec() < GetMaxKeyframeDistanceSec()));
   EXPECT_EQ(matches_requirements, IsBackgroundOptimizationCandidate());
 
   // Video is always paused when suspension is on and only if matches the
   // optimization criteria if the optimization is on.
   bool should_pause = IsMediaSuspendOn() ||
                       (IsBackgroundOptimizationOn() && matches_requirements);
   EXPECT_EQ(should_pause, ShouldPauseVideoWhenHidden());
 }
 
 TEST_P(WebMediaPlayerImplBackgroundBehaviorTest, AudioVideo) {
   SetMetadata(true, true);
 
   // Optimization requirements are the same for all platforms.
   bool matches_requirements =
-      (GetDurationSec() < GetAverageKeyframeDistanceSec()) ||
-      (GetAverageKeyframeDistanceSec() < 10);
+      (GetDurationSec() < GetMaxKeyframeDistanceSec()) ||
+      (GetAverageKeyframeDistanceSec() < GetMaxKeyframeDistanceSec());
 
   EXPECT_EQ(matches_requirements, IsBackgroundOptimizationCandidate());
   EXPECT_EQ(IsBackgroundOptimizationOn() && matches_requirements,
             ShouldDisableVideoWhenHidden());
 
   // Only pause audible videos on Android if both media suspend and resume
   // background videos is on. On Desktop
   EXPECT_EQ(IsMediaSuspendOn() && IsResumeBackgroundVideoEnabled(),
             ShouldPauseVideoWhenHidden());
 }
 
 INSTANTIATE_TEST_CASE_P(BackgroundBehaviorTestInstances,
                         WebMediaPlayerImplBackgroundBehaviorTest,
                         ::testing::Combine(::testing::Bool(),
                                            ::testing::Bool(),
                                            ::testing::Values(5, 300),
                                            ::testing::Values(5, 100),
+                                           ::testing::Bool(),
                                            ::testing::Bool()));
 
 }  // namespace media