webmediaplayer_ms.h revision f2477e01787aa58f445919b809d89e252beef54f 
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 CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_H_
6#define CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_H_
7
8#include "base/memory/ref_counted.h"
9#include "base/memory/scoped_ptr.h"
10#include "base/memory/weak_ptr.h"
11#include "base/synchronization/lock.h"
12#include "base/threading/thread_checker.h"
13#include "cc/layers/video_frame_provider.h"
14#include "media/filters/skcanvas_video_renderer.h"
15#include "skia/ext/platform_canvas.h"
16#include "third_party/WebKit/public/platform/WebMediaPlayer.h"
17#include "url/gurl.h"
18
19namespace blink {
20class WebFrame;
21class WebMediaPlayerClient;
22}
23
24namespace media {
25class MediaLog;
26}
27
28namespace webkit {
29class WebLayerImpl;
30}
31
32namespace content {
33class MediaStreamAudioRenderer;
34class MediaStreamClient;
35class VideoFrameProvider;
36class WebMediaPlayerDelegate;
37
38// WebMediaPlayerMS delegates calls from WebCore::MediaPlayerPrivate to
39// Chrome's media player when "src" is from media stream.
40//
41// WebMediaPlayerMS works with multiple objects, the most important ones are:
42//
43// VideoFrameProvider
44//   provides video frames for rendering.
45//
46// TODO(wjia): add AudioPlayer.
47// AudioPlayer
48//   plays audio streams.
49//
50// blink::WebMediaPlayerClient
51//   WebKit client of this media player object.
52class WebMediaPlayerMS
53    : public blink::WebMediaPlayer,
54      public cc::VideoFrameProvider,
55      public base::SupportsWeakPtr<WebMediaPlayerMS> {
56 public:
57  // Construct a WebMediaPlayerMS with reference to the client, and
58  // a MediaStreamClient which provides VideoFrameProvider.
59  WebMediaPlayerMS(blink::WebFrame* frame,
60                   blink::WebMediaPlayerClient* client,
61                   base::WeakPtr<WebMediaPlayerDelegate> delegate,
62                   MediaStreamClient* media_stream_client,
63                   media::MediaLog* media_log);
64  virtual ~WebMediaPlayerMS();
65
66  virtual void load(LoadType load_type,
67                    const blink::WebURL& url,
68                    CORSMode cors_mode) OVERRIDE;
69
70  // Playback controls.
71  virtual void play() OVERRIDE;
72  virtual void pause() OVERRIDE;
73  virtual bool supportsFullscreen() const OVERRIDE;
74  virtual bool supportsSave() const OVERRIDE;
75  virtual void seek(double seconds);
76  virtual void setRate(double rate);
77  virtual void setVolume(double volume);
78  virtual void setPreload(blink::WebMediaPlayer::Preload preload) OVERRIDE;
79  virtual const blink::WebTimeRanges& buffered() OVERRIDE;
80  virtual double maxTimeSeekable() const;
81
82  // Methods for painting.
83  virtual void paint(blink::WebCanvas* canvas,
84                     const blink::WebRect& rect,
85                     unsigned char alpha) OVERRIDE;
86
87  // True if the loaded media has a playable video/audio track.
88  virtual bool hasVideo() const OVERRIDE;
89  virtual bool hasAudio() const OVERRIDE;
90
91  // Dimensions of the video.
92  virtual blink::WebSize naturalSize() const OVERRIDE;
93
94  // Getters of playback state.
95  virtual bool paused() const OVERRIDE;
96  virtual bool seeking() const OVERRIDE;
97  virtual double duration() const;
98  virtual double currentTime() const;
99
100  // Internal states of loading and network.
101  virtual blink::WebMediaPlayer::NetworkState networkState() const OVERRIDE;
102  virtual blink::WebMediaPlayer::ReadyState readyState() const OVERRIDE;
103
104  virtual bool didLoadingProgress() const OVERRIDE;
105
106  virtual bool hasSingleSecurityOrigin() const OVERRIDE;
107  virtual bool didPassCORSAccessCheck() const OVERRIDE;
108
109  virtual double mediaTimeForTimeValue(double timeValue) const;
110
111  virtual unsigned decodedFrameCount() const OVERRIDE;
112  virtual unsigned droppedFrameCount() const OVERRIDE;
113  virtual unsigned audioDecodedByteCount() const OVERRIDE;
114  virtual unsigned videoDecodedByteCount() const OVERRIDE;
115
116  // VideoFrameProvider implementation.
117  virtual void SetVideoFrameProviderClient(
118      cc::VideoFrameProvider::Client* client) OVERRIDE;
119  virtual scoped_refptr<media::VideoFrame> GetCurrentFrame() OVERRIDE;
120  virtual void PutCurrentFrame(const scoped_refptr<media::VideoFrame>& frame)
121      OVERRIDE;
122
123 private:
124  // The callback for VideoFrameProvider to signal a new frame is available.
125  void OnFrameAvailable(const scoped_refptr<media::VideoFrame>& frame);
126  // Need repaint due to state change.
127  void RepaintInternal();
128
129  // The callback for source to report error.
130  void OnSourceError();
131
132  // Helpers that set the network/ready state and notifies the client if
133  // they've changed.
134  void SetNetworkState(blink::WebMediaPlayer::NetworkState state);
135  void SetReadyState(blink::WebMediaPlayer::ReadyState state);
136
137  // Getter method to |client_|.
138  blink::WebMediaPlayerClient* GetClient();
139
140  blink::WebFrame* frame_;
141
142  blink::WebMediaPlayer::NetworkState network_state_;
143  blink::WebMediaPlayer::ReadyState ready_state_;
144
145  blink::WebTimeRanges buffered_;
146
147  // Used for DCHECKs to ensure methods calls executed in the correct thread.
148  base::ThreadChecker thread_checker_;
149
150  blink::WebMediaPlayerClient* client_;
151
152  base::WeakPtr<WebMediaPlayerDelegate> delegate_;
153
154  MediaStreamClient* media_stream_client_;
155
156  // Specify content:: to disambiguate from cc::.
157  scoped_refptr<content::VideoFrameProvider> video_frame_provider_;
158  bool paused_;
159
160  // |current_frame_| is updated only on main thread. The object it holds
161  // can be freed on the compositor thread if it is the last to hold a
162  // reference but media::VideoFrame is a thread-safe ref-pointer.
163  scoped_refptr<media::VideoFrame> current_frame_;
164  // |current_frame_used_| is updated on both main and compositing thread.
165  // It's used to track whether |current_frame_| was painted for detecting
166  // when to increase |dropped_frame_count_|.
167  bool current_frame_used_;
168  base::Lock current_frame_lock_;
169  bool pending_repaint_;
170
171  scoped_ptr<webkit::WebLayerImpl> video_weblayer_;
172
173  // A pointer back to the compositor to inform it about state changes. This is
174  // not NULL while the compositor is actively using this webmediaplayer.
175  cc::VideoFrameProvider::Client* video_frame_provider_client_;
176
177  bool received_first_frame_;
178  bool sequence_started_;
179  base::TimeDelta start_time_;
180  unsigned total_frame_count_;
181  unsigned dropped_frame_count_;
182  media::SkCanvasVideoRenderer video_renderer_;
183
184  scoped_refptr<MediaStreamAudioRenderer> audio_renderer_;
185
186  scoped_refptr<media::MediaLog> media_log_;
187
188  DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerMS);
189};
190
191}  // namespace content
192
193#endif  // CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_MS_H_
194