#include "base/cancelable_callback.h"
#include "base/compiler_specific.h"
+#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "media/base/renderer_factory_selector.h"
#include "media/base/routing_token_callback.h"
#include "media/base/simple_watch_timer.h"
-#include "media/base/text_track.h"
#include "media/filters/demuxer_manager.h"
#include "media/mojo/mojom/media_metrics_provider.mojom.h"
#include "media/mojo/mojom/playback_events_recorder.mojom.h"
#if defined(TIZEN_MULTIMEDIA)
void Suspend() override;
void Resume() override;
+
+ bool SuspendedByPlayer() override { return was_suspended_by_player_; }
#endif
void OnFrozen() override;
void SuspendForFrameClosed() override;
bool HasAvailableVideoFrame() const override;
+ bool HasReadableVideoFrame() const override;
scoped_refptr<WebAudioSourceProviderImpl> GetAudioSourceProvider() override;
media::BufferingState state,
media::BufferingStateChangeReason reason) override;
void OnDurationChange() override;
- void OnAddTextTrack(const media::TextTrackConfig& config,
- media::AddTextTrackDoneCB done_cb) override;
+#if BUILDFLAG(IS_TIZEN_TV)
+ void SetParentalRatingResult(bool is_pass) override;
+#endif
void OnWaiting(media::WaitingReason reason) override;
void OnAudioConfigChange(const media::AudioDecoderConfig& config) override;
void OnVideoConfigChange(const media::VideoDecoderConfig& config) override;
void OnAudioPipelineInfoChange(const media::AudioPipelineInfo& info) override;
void OnVideoPipelineInfoChange(const media::VideoPipelineInfo& info) override;
#if defined(TIZEN_MULTIMEDIA)
+ void OnSeekableTimeChange(base::TimeDelta min_time,
+ base::TimeDelta max_time,
+ bool is_live) override;
+ void OnLivePlaybackComplete() override;
+
// Called if a player in the browser process is suspended.
- void OnRequestSuspend() override;
+ void OnRequestSuspend(bool resource_conflicted) override;
+
+ void FullscreenModeToggled();
#endif
// media::DemuxerManager::Client overrides.
void RestartForHls() override;
bool IsSecurityOriginCryptographic() const override;
void UpdateLoadedUrl(const GURL& url) override;
+ void DemuxerRequestsSeek(base::TimeDelta seek_time) override;
#if BUILDFLAG(ENABLE_FFMPEG)
void AddAudioTrack(const std::string& id,
#endif // BUILDFLAG(ENABLE_FFMPEG)
#if BUILDFLAG(ENABLE_HLS_DEMUXER)
+ void GetUrlData(const GURL& gurl,
+ base::OnceCallback<void(scoped_refptr<UrlData>)> cb);
base::SequenceBound<media::HlsDataSourceProvider> GetHlsDataSourceProvider()
override;
#endif // BUILDFLAG(ENABLE_HLS_DEMUXER)
base::TimeDelta GetCurrentTimeInternal() const;
// Called by the compositor the very first time a frame is received.
- void OnFirstFrame(base::TimeTicks frame_time);
+ void OnFirstFrame(base::TimeTicks frame_time, bool is_frame_readable);
// Records the encryption scheme used by the stream |stream_name|. This is
// only recorded when metadata is available.
bool is_streaming,
bool is_static);
- WebLocalFrame* const frame_;
+ // Notifies the `client_` and the `delegate_` about metadata change.
+ void DidMediaMetadataChange();
+
+ const raw_ptr<WebLocalFrame, ExperimentalRenderer> frame_;
WebMediaPlayer::NetworkState network_state_ =
WebMediaPlayer::kNetworkStateEmpty;
bool overlay_enabled_ = false;
+ // Cors and Caching flags set during `Load` and used while creating demuxers.
+ CorsMode cors_mode_ = kCorsModeUnspecified;
+ bool is_cache_disabled_ = false;
+
// Whether the current decoder requires a restart on overlay transitions.
bool decoder_requires_restart_for_overlay_ = false;
- WebMediaPlayerClient* const client_;
- WebMediaPlayerEncryptedMediaClient* const encrypted_client_;
+ const raw_ptr<WebMediaPlayerClient, ExperimentalRenderer> client_;
+ const raw_ptr<WebMediaPlayerEncryptedMediaClient, ExperimentalRenderer>
+ encrypted_client_;
// WebMediaPlayer notifies the |delegate_| of playback state changes using
// |delegate_id_|; an id provided after registering with the delegate. The
// before the frame is destroyed). RenderFrameImpl owns |delegate_| and is
// guaranteed to outlive |this|; thus it is safe to store |delegate_| as a raw
// pointer.
- WebMediaPlayerDelegate* delegate_;
+ raw_ptr<WebMediaPlayerDelegate, ExperimentalRenderer> delegate_;
int delegate_id_ = 0;
// The playback state last reported to |delegate_|, to avoid setting duplicate
// Manages the lifetime of the DataSource, and soon the Demuxer.
std::unique_ptr<media::DemuxerManager> demuxer_manager_;
- const base::TickClock* tick_clock_ = nullptr;
+ raw_ptr<const base::TickClock, ExperimentalRenderer> tick_clock_ = nullptr;
std::unique_ptr<BufferedDataSourceHostImpl> buffered_data_source_host_;
- UrlIndex* const url_index_;
+ const raw_ptr<UrlIndex, ExperimentalRenderer> url_index_;
scoped_refptr<viz::RasterContextProvider> raster_context_provider_;
// Video rendering members.
// unimportant.
bool suppress_destruction_errors_ = false;
- // TODO(dalecurtis): The following comment is inaccurate as this value is also
- // used for, for example, data URLs.
- // Used for HLS playback and in certain fallback paths (e.g. on older devices
- // that can't support the unified media pipeline).
- GURL loaded_url_ ALLOW_DISCOURAGED_TYPE("Avoids conversion in media code");
-
// NOTE: |using_media_player_renderer_| is set based on the usage of a
// MediaResource::Type::URL in StartPipeline(). This works because
// MediaPlayerRendererClientFactory is the only factory that uses
// to false as soon as |has_first_frame_| is set to true.
bool needs_first_frame_ = false;
+ // Whether the rendered frame is readable, e.g. can be converted to image.
+ bool is_frame_readable_ = false;
+
// True if StartPipeline() completed a lazy load startup.
bool did_lazy_load_ = false;
#if defined(TIZEN_MULTIMEDIA)
bool was_suspended_by_player_ = false;
+
+ // used for live streams.
+ bool is_live_stream_ = false;
+ base::TimeDelta min_seekable_time_;
+ base::TimeDelta max_seekable_time_;
#endif
// Request pipeline to suspend. It should not block other signals after
projects / platform / framework / web / chromium-efl.git / blobdiff