fix canplaythrough

media/blink/buffered_data_source_host_impl.h

 // Copyright 2014 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.
 
 #ifndef MEDIA_BLINK_BUFFERED_DATA_SOURCE_HOST_IMPL_H_
 #define MEDIA_BLINK_BUFFERED_DATA_SOURCE_HOST_IMPL_H_
 
 #include <stdint.h>
+#include <deque>
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "media/base/ranges.h"
 #include "media/blink/interval_map.h"
 #include "media/blink/media_blink_export.h"
 
 namespace media {
 
 // Interface for testing purposes.
 class MEDIA_BLINK_EXPORT BufferedDataSourceHost {
  public:
   // Notify the host of the total size of the media file.
   virtual void SetTotalBytes(int64_t total_bytes) = 0;
 
   // Notify the host that byte range [start,end] has been buffered.
   // TODO(fischman): remove this method when demuxing is push-based instead of
   // pull-based.  http://crbug.com/131444
   virtual void AddBufferedByteRange(int64_t start, int64_t end) = 0;
 
  protected:
   virtual ~BufferedDataSourceHost() {}
 };
 
 // Provides an implementation of BufferedDataSourceHost that translates the
 // buffered byte ranges into estimated time ranges.
 class MEDIA_BLINK_EXPORT BufferedDataSourceHostImpl
     : public BufferedDataSourceHost {
  public:
-  BufferedDataSourceHostImpl();
+  explicit BufferedDataSourceHostImpl(const base::Closure& progress_cb);
   ~BufferedDataSourceHostImpl() override;
 
   // BufferedDataSourceHost implementation.
   void SetTotalBytes(int64_t total_bytes) override;
   void AddBufferedByteRange(int64_t start, int64_t end) override;
 
   // Translate the byte ranges to time ranges and append them to the list.
   // TODO(sandersd): This is a confusing name, find something better.
   void AddBufferedTimeRanges(
       Ranges<base::TimeDelta>* buffered_time_ranges,
       base::TimeDelta media_duration) const;
 
   bool DidLoadingProgress();
 
+  // Returns true if we have enough buffered bytes to play from now
+  // until the end of media
+  bool CanPlayThrough(base::TimeDelta current_position,
+                      base::TimeDelta media_duration,
+                      double playback_rate) const;
+
  private:
+  // Returns number of bytes not yet loaded in the given interval.
+  int64_t UnloadedBytesInInterval(const Interval<int64_t>& interval) const;
+
+  // Returns an estimate of the download rate.
+  // Returns 0.0 if an estimate cannot be made.
+  double DownloadRate() const;
+
   // Total size of the data source.
   int64_t total_bytes_;
 
   // List of buffered byte ranges for estimating buffered time.
   // The InterValMap value is 1 for bytes that are buffered, 0 otherwise.
   IntervalMap<int64_t, int> buffered_byte_ranges_;
 
   // True when AddBufferedByteRange() has been called more recently than
   // DidLoadingProgress().
   bool did_loading_progress_;
 
+  // Contains how much we had downloaded at a given time.
+  // Pruned to contain roughly the last 10 seconds of data.
+  std::deque<std::pair<base::TimeTicks, uint64_t>> download_history_;

[sandersd (OOO until July 31), 2017/04/25 22:00:57]

I'm a bit worried about the size and complexity of this deque. I think it should
be abstracted into its own class, and I would propose implementing it using a
fixed number of tagged bins instead.

Specifically, something like this: struct { int64_t time; int64_t bytes; }
bins[10];

(This example structure support second-granularity tracking over ten seconds in
a fixed amount of memory; each transfer just gets counted into bin[now % 10].)

[hubbe, 2017/04/25 23:47:03]

Given that each entry represents at least 1000 bytes, the overhead seems pretty
small. I didn't have a lot of luck with reducing the complexity, and I don't
think doing the modular math myself is simpler than letting deque do it for me.

As for breaking it out: I could, but personally I don't think it's worth it.
Dale, what do you think?

[DaleCurtis, 2017/04/26 00:11:26]

What does the size of this look like currently? I don't think this class does
much so I'm happy to have it in here so long as it's well tested. I share Dan's
concerns about the growth of it though, so having an idea of what it looks like
after 15 minutes of playback would be interesting.

[hubbe, 2017/04/26 00:24:27]

There is a maximum of 1000 entries right now.

+  base::Closure progress_cb_;
+
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceHostImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_BUFFERED_DATA_SOURCE_HOST_IMPL_H_