1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "media/blink/buffered_data_source_host_impl.h"
6 
7 #include "base/bind.h"
8 #include "base/macros.h"
9 #include "base/test/simple_test_tick_clock.h"
10 #include "testing/gtest/include/gtest/gtest.h"
11 
12 namespace media {
13 
14 class BufferedDataSourceHostImplTest : public testing::Test {
15  public:
BufferedDataSourceHostImplTest()16   BufferedDataSourceHostImplTest()
17       : host_(base::BindRepeating(
18                   &BufferedDataSourceHostImplTest::ProgressCallback,
19                   base::Unretained(this)),
20               &clock_) {}
21 
Add()22   void Add() {
23     host_.AddBufferedTimeRanges(&ranges_, base::TimeDelta::FromSeconds(10));
24   }
25 
ProgressCallback()26   void ProgressCallback() { progress_callback_calls_++; }
27 
28  protected:
29   int progress_callback_calls_ = 0;
30   BufferedDataSourceHostImpl host_;
31   Ranges<base::TimeDelta> ranges_;
32   base::SimpleTestTickClock clock_;
33 
34   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceHostImplTest);
35 };
36 
TEST_F(BufferedDataSourceHostImplTest,Empty)37 TEST_F(BufferedDataSourceHostImplTest, Empty) {
38   EXPECT_FALSE(host_.DidLoadingProgress());
39   Add();
40   EXPECT_EQ(0u, ranges_.size());
41 }
42 
TEST_F(BufferedDataSourceHostImplTest,AddBufferedTimeRanges)43 TEST_F(BufferedDataSourceHostImplTest, AddBufferedTimeRanges) {
44   host_.AddBufferedByteRange(10, 20);
45   host_.SetTotalBytes(100);
46   Add();
47   EXPECT_EQ(1u, ranges_.size());
48   EXPECT_EQ(base::TimeDelta::FromSeconds(1), ranges_.start(0));
49   EXPECT_EQ(base::TimeDelta::FromSeconds(2), ranges_.end(0));
50 }
51 
TEST_F(BufferedDataSourceHostImplTest,AddBufferedTimeRanges_Merges)52 TEST_F(BufferedDataSourceHostImplTest, AddBufferedTimeRanges_Merges) {
53   ranges_.Add(base::TimeDelta::FromSeconds(0), base::TimeDelta::FromSeconds(1));
54   host_.AddBufferedByteRange(10, 20);
55   host_.SetTotalBytes(100);
56   Add();
57   EXPECT_EQ(1u, ranges_.size());
58   EXPECT_EQ(base::TimeDelta::FromSeconds(0), ranges_.start(0));
59   EXPECT_EQ(base::TimeDelta::FromSeconds(2), ranges_.end(0));
60 }
61 
TEST_F(BufferedDataSourceHostImplTest,AddBufferedTimeRanges_Snaps)62 TEST_F(BufferedDataSourceHostImplTest, AddBufferedTimeRanges_Snaps) {
63   host_.AddBufferedByteRange(5, 995);
64   host_.SetTotalBytes(1000);
65   Add();
66   EXPECT_EQ(1u, ranges_.size());
67   EXPECT_EQ(base::TimeDelta::FromSeconds(0), ranges_.start(0));
68   EXPECT_EQ(base::TimeDelta::FromSeconds(10), ranges_.end(0));
69 }
70 
TEST_F(BufferedDataSourceHostImplTest,SetTotalBytes)71 TEST_F(BufferedDataSourceHostImplTest, SetTotalBytes) {
72   host_.AddBufferedByteRange(10, 20);
73   Add();
74   EXPECT_EQ(0u, ranges_.size());
75 
76   host_.SetTotalBytes(100);
77   Add();
78   EXPECT_EQ(1u, ranges_.size());
79 }
80 
TEST_F(BufferedDataSourceHostImplTest,DidLoadingProgress)81 TEST_F(BufferedDataSourceHostImplTest, DidLoadingProgress) {
82   host_.AddBufferedByteRange(10, 20);
83   EXPECT_TRUE(host_.DidLoadingProgress());
84   EXPECT_FALSE(host_.DidLoadingProgress());
85 }
86 
TEST_F(BufferedDataSourceHostImplTest,CanPlayThrough)87 TEST_F(BufferedDataSourceHostImplTest, CanPlayThrough) {
88   host_.SetTotalBytes(100000);
89   EXPECT_EQ(100000,
90             host_.UnloadedBytesInInterval(Interval<int64_t>(0, 100000)));
91   host_.AddBufferedByteRange(0, 10000);
92   clock_.Advance(base::TimeDelta::FromSeconds(1));
93   host_.AddBufferedByteRange(10000, 20000);
94   clock_.Advance(base::TimeDelta::FromSeconds(1));
95   host_.AddBufferedByteRange(20000, 30000);
96   clock_.Advance(base::TimeDelta::FromSeconds(1));
97   host_.AddBufferedByteRange(30000, 40000);
98   clock_.Advance(base::TimeDelta::FromSeconds(1));
99   host_.AddBufferedByteRange(40000, 50000);
100   clock_.Advance(base::TimeDelta::FromSeconds(1));
101   EXPECT_EQ(50000, host_.UnloadedBytesInInterval(Interval<int64_t>(0, 100000)));
102   host_.AddBufferedByteRange(50000, 60000);
103   clock_.Advance(base::TimeDelta::FromSeconds(1));
104   host_.AddBufferedByteRange(60000, 70000);
105   clock_.Advance(base::TimeDelta::FromSeconds(1));
106   host_.AddBufferedByteRange(70000, 80000);
107   clock_.Advance(base::TimeDelta::FromSeconds(1));
108   host_.AddBufferedByteRange(80000, 90000);
109   // Download rate is allowed to be estimated low, but not high.
110   EXPECT_LE(host_.DownloadRate(), 10000.0f);
111   EXPECT_GE(host_.DownloadRate(), 9000.0f);
112   EXPECT_EQ(10000, host_.UnloadedBytesInInterval(Interval<int64_t>(0, 100000)));
113   EXPECT_EQ(9, progress_callback_calls_);
114   // If the video is 0.1s we can't play through.
115   EXPECT_FALSE(host_.CanPlayThrough(base::TimeDelta(),
116                                     base::TimeDelta::FromSecondsD(0.01), 1.0));
117   // If the video is 1000s we can play through.
118   EXPECT_TRUE(host_.CanPlayThrough(base::TimeDelta(),
119                                    base::TimeDelta::FromSecondsD(1000.0), 1.0));
120   // No more downloads for 1000 seconds...
121   clock_.Advance(base::TimeDelta::FromSeconds(1000));
122   // Can't play through..
123   EXPECT_FALSE(host_.CanPlayThrough(base::TimeDelta(),
124                                     base::TimeDelta::FromSecondsD(100.0), 1.0));
125   host_.AddBufferedByteRange(90000, 100000);
126   clock_.Advance(base::TimeDelta::FromSeconds(1));
127   EXPECT_EQ(0, host_.UnloadedBytesInInterval(Interval<int64_t>(0, 100000)));
128 
129   // Media is fully downloaded, so we can certainly play through, even if
130   // we only have 0.01 seconds to do it.
131   EXPECT_TRUE(host_.CanPlayThrough(base::TimeDelta(),
132                                    base::TimeDelta::FromSecondsD(0.01), 1.0));
133 }
134 
TEST_F(BufferedDataSourceHostImplTest,CanPlayThroughSmallAdvances)135 TEST_F(BufferedDataSourceHostImplTest, CanPlayThroughSmallAdvances) {
136   host_.SetTotalBytes(20000);
137   EXPECT_EQ(20000, host_.UnloadedBytesInInterval(Interval<int64_t>(0, 20000)));
138   for (int j = 1; j <= 100; j++) {
139     host_.AddBufferedByteRange(0, j * 100);
140     clock_.Advance(base::TimeDelta::FromSecondsD(0.01));
141   }
142   // Download rate is allowed to be estimated low, but not high.
143   EXPECT_LE(host_.DownloadRate(), 10000.0f);
144   EXPECT_GE(host_.DownloadRate(), 9000.0f);
145   EXPECT_EQ(10000, host_.UnloadedBytesInInterval(Interval<int64_t>(0, 20000)));
146   EXPECT_EQ(100, progress_callback_calls_);
147   // If the video is 0.1s we can't play through.
148   EXPECT_FALSE(host_.CanPlayThrough(base::TimeDelta(),
149                                     base::TimeDelta::FromSecondsD(0.01), 1.0));
150   // If the video is 1000s we can play through.
151   EXPECT_TRUE(host_.CanPlayThrough(base::TimeDelta(),
152                                    base::TimeDelta::FromSecondsD(1000.0), 1.0));
153 }
154 
155 }  // namespace media
156