Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(126)

Side by Side Diff: webkit/renderer/media/buffered_data_source.h

Issue 18123002: Migrate webkit/renderer/media/ to content/renderer/media/. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: delegates Created 7 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright 2013 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 #ifndef WEBKIT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
6 #define WEBKIT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
7
8 #include <string>
9
10 #include "base/callback.h"
11 #include "base/memory/scoped_ptr.h"
12 #include "base/synchronization/lock.h"
13 #include "googleurl/src/gurl.h"
14 #include "media/base/data_source.h"
15 #include "media/base/ranges.h"
16 #include "webkit/renderer/media/buffered_resource_loader.h"
17 #include "webkit/renderer/media/preload.h"
18
19 namespace base {
20 class MessageLoopProxy;
21 }
22
23 namespace media {
24 class MediaLog;
25 }
26
27 namespace webkit_media {
28
29 // A data source capable of loading URLs and buffering the data using an
30 // in-memory sliding window.
31 //
32 // BufferedDataSource must be created and initialized on the render thread
33 // before being passed to other threads. It may be deleted on any thread.
34 class BufferedDataSource : public media::DataSource {
35 public:
36 typedef base::Callback<void(bool)> DownloadingCB;
37
38 // |downloading_cb| will be called whenever the downloading/paused state of
39 // the source changes.
40 BufferedDataSource(const scoped_refptr<base::MessageLoopProxy>& render_loop,
41 WebKit::WebFrame* frame,
42 media::MediaLog* media_log,
43 const DownloadingCB& downloading_cb);
44 virtual ~BufferedDataSource();
45
46 // Initialize this object using |url| and |cors_mode|, executing |init_cb|
47 // with the result of initialization when it has completed.
48 //
49 // Method called on the render thread.
50 typedef base::Callback<void(bool)> InitializeCB;
51 void Initialize(
52 const GURL& url,
53 BufferedResourceLoader::CORSMode cors_mode,
54 const InitializeCB& init_cb);
55
56 // Adjusts the buffering algorithm based on the given preload value.
57 void SetPreload(Preload preload);
58
59 // Returns true if the media resource has a single origin, false otherwise.
60 // Only valid to call after Initialize() has completed.
61 //
62 // Method called on the render thread.
63 bool HasSingleOrigin();
64
65 // Returns true if the media resource passed a CORS access control check.
66 bool DidPassCORSAccessCheck() const;
67
68 // Cancels initialization, any pending loaders, and any pending read calls
69 // from the demuxer. The caller is expected to release its reference to this
70 // object and never call it again.
71 //
72 // Method called on the render thread.
73 void Abort();
74
75 // media::DataSource implementation.
76 // Called from demuxer thread.
77 virtual void set_host(media::DataSourceHost* host) OVERRIDE;
78 virtual void Stop(const base::Closure& closure) OVERRIDE;
79 virtual void SetPlaybackRate(float playback_rate) OVERRIDE;
80
81 virtual void Read(int64 position, int size, uint8* data,
82 const media::DataSource::ReadCB& read_cb) OVERRIDE;
83 virtual bool GetSize(int64* size_out) OVERRIDE;
84 virtual bool IsStreaming() OVERRIDE;
85 virtual void SetBitrate(int bitrate) OVERRIDE;
86
87 protected:
88 // A factory method to create a BufferedResourceLoader based on the read
89 // parameters. We can override this file to object a mock
90 // BufferedResourceLoader for testing.
91 virtual BufferedResourceLoader* CreateResourceLoader(
92 int64 first_byte_position, int64 last_byte_position);
93
94 private:
95 friend class BufferedDataSourceTest;
96
97 // Task posted to perform actual reading on the render thread.
98 void ReadTask();
99
100 // Cancels oustanding callbacks and sets |stop_signal_received_|. Safe to call
101 // from any thread.
102 void StopInternal_Locked();
103
104 // Stops |loader_| if present. Used by Abort() and Stop().
105 void StopLoader();
106
107 // This task uses the current playback rate with the previous playback rate
108 // to determine whether we are going from pause to play and play to pause,
109 // and signals the buffered resource loader accordingly.
110 void SetPlaybackRateTask(float playback_rate);
111
112 // Tells |loader_| the bitrate of the media.
113 void SetBitrateTask(int bitrate);
114
115 // The method that performs actual read. This method can only be executed on
116 // the render thread.
117 void ReadInternal();
118
119 // BufferedResourceLoader::Start() callback for initial load.
120 void StartCallback(BufferedResourceLoader::Status status);
121
122 // BufferedResourceLoader::Start() callback for subsequent loads (i.e.,
123 // when accessing ranges that are outside initial buffered region).
124 void PartialReadStartCallback(BufferedResourceLoader::Status status);
125
126 // BufferedResourceLoader callbacks.
127 void ReadCallback(BufferedResourceLoader::Status status, int bytes_read);
128 void LoadingStateChangedCallback(BufferedResourceLoader::LoadingState state);
129 void ProgressCallback(int64 position);
130
131 // Report a buffered byte range [start,end] or queue it for later
132 // reporting if set_host() hasn't been called yet.
133 void ReportOrQueueBufferedBytes(int64 start, int64 end);
134
135 void UpdateHostState_Locked();
136
137 base::WeakPtrFactory<BufferedDataSource> weak_factory_;
138 base::WeakPtr<BufferedDataSource> weak_this_;
139
140 // URL of the resource requested.
141 GURL url_;
142 // crossorigin attribute on the corresponding HTML media element, if any.
143 BufferedResourceLoader::CORSMode cors_mode_;
144
145 // The total size of the resource. Set during StartCallback() if the size is
146 // known, otherwise it will remain kPositionNotSpecified until the size is
147 // determined by reaching EOF.
148 int64 total_bytes_;
149
150 // Some resources are assumed to be fully buffered (i.e., file://) so we don't
151 // need to report what |loader_| has buffered.
152 bool assume_fully_buffered_;
153
154 // This value will be true if this data source can only support streaming.
155 // i.e. range request is not supported.
156 bool streaming_;
157
158 // A webframe for loading.
159 WebKit::WebFrame* frame_;
160
161 // A resource loader for the media resource.
162 scoped_ptr<BufferedResourceLoader> loader_;
163
164 // Callback method from the pipeline for initialization.
165 InitializeCB init_cb_;
166
167 // Read parameters received from the Read() method call. Must be accessed
168 // under |lock_|.
169 class ReadOperation;
170 scoped_ptr<ReadOperation> read_op_;
171
172 // This buffer is intermediate, we use it for BufferedResourceLoader to write
173 // to. And when read in BufferedResourceLoader is done, we copy data from
174 // this buffer to |read_buffer_|. The reason for an additional copy is that
175 // we don't own |read_buffer_|. But since the read operation is asynchronous,
176 // |read_buffer| can be destroyed at any time, so we only copy into
177 // |read_buffer| in the final step when it is safe.
178 // Memory is allocated for this member during initialization of this object
179 // because we want buffer to be passed into BufferedResourceLoader to be
180 // always non-null. And by initializing this member with a default size we can
181 // avoid creating zero-sized buffered if the first read has zero size.
182 scoped_ptr<uint8[]> intermediate_read_buffer_;
183 int intermediate_read_buffer_size_;
184
185 // The message loop of the render thread.
186 const scoped_refptr<base::MessageLoopProxy> render_loop_;
187
188 // Protects |stop_signal_received_| and |read_op_|.
189 base::Lock lock_;
190
191 // Whether we've been told to stop via Abort() or Stop().
192 bool stop_signal_received_;
193
194 // This variable is true when the user has requested the video to play at
195 // least once.
196 bool media_has_played_;
197
198 // This variable holds the value of the preload attribute for the video
199 // element.
200 Preload preload_;
201
202 // Bitrate of the content, 0 if unknown.
203 int bitrate_;
204
205 // Current playback rate.
206 float playback_rate_;
207
208 // Buffered byte ranges awaiting set_host() being called to report to host().
209 media::Ranges<int64> queued_buffered_byte_ranges_;
210
211 scoped_refptr<media::MediaLog> media_log_;
212
213 DownloadingCB downloading_cb_;
214
215 DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
216 };
217
218 } // namespace webkit_media
219
220 #endif // WEBKIT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698