--- /dev/null
+// Copyright 2015 Samsung Electronics Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/media/browser_mediapacket_manager.h"
+
+#include <media_packet.h>
+
+#include "content/common/media/efl/media_player_messages_efl.h"
+#include "content/public/browser/browser_thread.h"
+#include "ipc/ipc_message_macros.h"
+
+namespace {
+
+void DoDestroyMediaPacket(media_packet_h packet) {
+ if (MEDIA_PACKET_ERROR_NONE != media_packet_destroy(packet))
+ LOG(WARNING) << "Fail to release media_packet";
+}
+
+} // namespace
+
+namespace content {
+
+scoped_refptr<BrowserMessageFilter> CreateBrowserMediapacketManager() {
+ return new BrowserMediaPacketManager();
+}
+
+BrowserMediaPacketManager::BrowserMediaPacketManager()
+ : BrowserMessageFilter(MediaPlayerMsgStart) {}
+
+BrowserMediaPacketManager::~BrowserMediaPacketManager() {}
+
+bool BrowserMediaPacketManager::OnMessageReceived(
+ const IPC::Message& message) {
+ bool handled = true;
+ IPC_BEGIN_MESSAGE_MAP(BrowserMediaPacketManager, message)
+ IPC_MESSAGE_HANDLER(MediaPlayerEflHostMsg_ReleaseTbmBuffer,
+ ReleaseMediaPacket)
+ IPC_MESSAGE_UNHANDLED(handled = false)
+ IPC_END_MESSAGE_MAP()
+ return handled;
+}
+
+void BrowserMediaPacketManager::ReleaseMediaPacket(
+ gfx::TbmBufferHandle packet) {
+ DLOG(INFO) << "ReleaseMediaPacket, media_packet: " << packet.media_packet;
+ BrowserThread::PostDelayedTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&DoDestroyMediaPacket,
+ static_cast<media_packet_h>(packet.media_packet)),
+ base::TimeDelta::FromMilliseconds(40));
+}
+
+} // namespace content
--- /dev/null
+// Copyright 2015 Samsung Electronics Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_BROWSER_MEDIA_BROWSER_MEDIAPACKET_MANAGER_H_
+#define CONTENT_BROWSER_MEDIA_BROWSER_MEDIAPACKET_MANAGER_H_
+
+#include "content/public/browser/browser_message_filter.h"
+#include "ui/gfx/gpu_memory_buffer.h"
+
+namespace content {
+
+class CONTENT_EXPORT BrowserMediaPacketManager : public BrowserMessageFilter {
+ public:
+ BrowserMediaPacketManager();
+ bool OnMessageReceived(const IPC::Message& message) override;
+
+ protected:
+ friend class base::RefCountedThreadSafe<BrowserMediaPacketManager>;
+ ~BrowserMediaPacketManager() override;
+
+ private:
+ void ReleaseMediaPacket(gfx::TbmBufferHandle packet);
+
+ DISALLOW_COPY_AND_ASSIGN(BrowserMediaPacketManager);
+};
+
+} // namespace content
+
+#endif // CONTENT_BROWSER_MEDIA_BROWSER_MEDIAPACKET_MANAGER_H_
RenderFrameHost* render_frame_host)
: current_player_(-1),
render_frame_host_(render_frame_host),
- web_contents_(WebContents::FromRenderFrameHost(render_frame_host)),
- weak_ptr_factory_(this) {
+ web_contents_(WebContents::FromRenderFrameHost(render_frame_host)) {
}
BrowserMediaPlayerManagerEfl::~BrowserMediaPlayerManagerEfl() {
- for (auto& player : players_) {
- player->Destroy();
- }
- players_.weak_clear();
+ // Players can be destroyed during destruction of BMPM without clear(),
+ // but not to make destruction order dependencies with other member variables
+ // we explicitly destroy player instances here.
+ players_.clear();
}
media::MediaPlayerEfl* BrowserMediaPlayerManagerEfl::GetPlayer(
Send(new MediaPlayerEflMsg_NewTbmBufferAvailable(
GetRoutingID(), player_id, tbm_handle, timestamp));
}
-
-void BrowserMediaPlayerManagerEfl::OnTbmBufferRelease(
- int player_id, gfx::TbmBufferHandle handle) {
- DLOG(INFO) << "Release media_packet:" << handle.media_packet;
- media::MediaPlayerEfl* player = GetPlayer(player_id);
- if (player)
- player->DestroyMediaPacket(
- static_cast<media_packet_h>(handle.media_packet));
-}
#endif
void BrowserMediaPlayerManagerEfl::OnTimeChanged(int player_id) {
for (auto it = players_.begin(); it != players_.end(); ++it) {
media::MediaPlayerEfl* player = *it;
if (player->GetPlayerId() == player_id) {
- players_.weak_erase(it);
- player->Destroy();
+ players_.erase(it);
if (!init_queue_.empty()) {
if(player_id == init_queue_.front()) {
void OnNewTbmBufferAvailable(
int player_id, gfx::TbmBufferHandle tbm_handle,
base::TimeDelta timestamp) override;
- void OnTbmBufferRelease(
- int player_id, gfx::TbmBufferHandle tbm_handle);
#endif
// Helper function to handle IPC from RenderMediaPlayerMangaerEfl.
WebContents* web_contents() const { return web_contents_; }
private:
- int current_player_;
-
- // An array of managed players.
- ScopedVector<media::MediaPlayerEfl> players_;
- RenderFrameHost* render_frame_host_;
- WebContents* const web_contents_;
- base::WeakPtrFactory<BrowserMediaPlayerManagerEfl> weak_ptr_factory_;
-
void SuspendPlayers();
void PausePlayers(int player_id);
void InitNextPlayer();
void RemovePlayerFromResumedQueue(int player_id);
void CleanUpResumedQueue();
+ int current_player_;
+
+ // An array of managed players.
+ ScopedVector<media::MediaPlayerEfl> players_;
+ RenderFrameHost* render_frame_host_;
+ WebContents* const web_contents_;
+
// A queue to initialize player including preroll.
std::deque<int> init_queue_;
std::deque<int> resumed_queue_;
IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_Seek,
GetMediaPlayerManager(render_frame_host),
BrowserMediaPlayerManagerEfl::OnSeek)
-#if defined(TIZEN_TBM_SUPPORT)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_ReleaseTbmBuffer,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnTbmBufferRelease)
-#endif
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
base::TimeDelta /* time stamp */)
// Requests to release tbm buffer.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_ReleaseTbmBuffer,
- int /* player_id */,
- gfx::TbmBufferHandle /* Handle */)
+IPC_MESSAGE_CONTROL1(MediaPlayerEflHostMsg_ReleaseTbmBuffer,
+ gfx::TbmBufferHandle /* Handle */)
#endif
// Seek.
'browser/media/efl/browser_media_player_manager_efl.h',
],
}], # tizen_multimedia_support==1
+ ['tizen_tbm_support==1', {
+ 'sources': [
+ 'browser/media/browser_mediapacket_manager.cc',
+ 'browser/media/browser_mediapacket_manager.h',
+ ],
+ }], # tizen_tbm_support==1
['enable_web_speech==0', {
'sources/': [
['exclude', '^browser/speech/'],
#include "base/bind.h"
#include "base/message_loop/message_loop.h"
#include "content/common/media/efl/media_player_messages_efl.h"
+#include "content/public/renderer/render_thread.h"
#include "content/renderer/media/efl/webmediaplayer_efl.h"
#include "media/base/bind_to_current_loop.h"
tbm_handle, timestamp,
media::BindToCurrentLoop(base::Bind(
&RendererMediaPlayerManager::OnTbmBufferRelease,
- base::Unretained(this), player_id, tbm_handle)));
+ base::Unretained(this), tbm_handle)));
}
void RendererMediaPlayerManager::OnTbmBufferRelease(
- int player_id, gfx::TbmBufferHandle tbm_handle) {
- DLOG(INFO) << __FUNCTION__
- << " player_id: " << player_id
- << ", media_packet: " << tbm_handle.media_packet;
- Send(new MediaPlayerEflHostMsg_ReleaseTbmBuffer(routing_id(), player_id,
- tbm_handle));
+ gfx::TbmBufferHandle tbm_handle) {
+ RenderThread::Get()->Send(
+ new MediaPlayerEflHostMsg_ReleaseTbmBuffer(tbm_handle));
}
#endif
#if defined(TIZEN_TBM_SUPPORT)
void OnNewTbmBufferAvailable(int player_id, gfx::TbmBufferHandle tbm_handle,
base::TimeDelta timestamp);
- void OnTbmBufferRelease(int player_id, gfx::TbmBufferHandle tbm_handle);
+ void OnTbmBufferRelease(gfx::TbmBufferHandle tbm_handle);
#endif
WebMediaPlayerEfl* GetMediaPlayer(int player_id);
#include "media/base/efl/media_player_efl.h"
-#include "content/public/browser/browser_thread.h"
-#include "media/base/efl/media_player_manager_efl.h"
-
-#if defined(TIZEN_TBM_SUPPORT)
#include <media_packet.h>
-namespace {
-
-void DoDestroyMediaPacket(media_packet_h packet) {
- if (MEDIA_PACKET_ERROR_NONE != media_packet_destroy(packet))
- LOG(WARNING) << "Fail to release media_packet";
-}
-
-} // namespace
-#endif
+#include "content/public/browser/browser_thread.h"
+#include "media/base/efl/media_player_manager_efl.h"
namespace media {
-MediaPlayerEfl::MediaPlayerEfl(int player_id, MediaPlayerManager* manager)
- : destructing_(false), width_(0), height_(0), player_id_(player_id),
- suspended_(false), manager_(manager) {}
+MediaPlayerEfl::MediaPlayerEfl(int player_id,
+ MediaPlayerManager* manager)
+ : width_(0), height_(0), player_id_(player_id), suspended_(false),
+ manager_(manager) {}
#if defined(TIZEN_TBM_SUPPORT)
-void MediaPlayerEfl::DestroyMediaPacket(media_packet_h packet) {
- // TODO(max): 40 ms delay is a workaround which should be removed.
- // Currently sometimes GLImage accesses |tbm_surface| after releasing it.
- content::BrowserThread::PostDelayedTask(
- content::BrowserThread::IO, FROM_HERE,
- base::Bind(&DoDestroyMediaPacket, packet),
- base::TimeDelta::FromMilliseconds(40));
-}
-
-void MediaPlayerEfl::DeliverMediaPacket(media_packet_h packet) {
+void MediaPlayerEfl::DeliverMediaPacket(ScopedMediaPacket packet) {
tbm_surface_info_s suf_info = {0, };
tbm_surface_h tbm_surface = nullptr;
if (MEDIA_PACKET_ERROR_NONE !=
- media_packet_get_tbm_surface(packet, &tbm_surface)) {
+ media_packet_get_tbm_surface(packet.get(), &tbm_surface)) {
LOG(ERROR) << "|media_packet_get_tbm_surface| failed";
- DestroyMediaPacket(packet);
return;
}
if (TBM_SURFACE_ERROR_NONE != tbm_surface_get_info(tbm_surface, &suf_info)) {
LOG(ERROR) << "|tbm_surface_get_info| failed";
- DestroyMediaPacket(packet);
return;
}
height_ = static_cast<int>(suf_info.height);
// Format will always convert to I420
- manager_->OnMediaDataChange(
+ manager()->OnMediaDataChange(
GetPlayerId(), TBM_FORMAT_YUV420, height_, width_, MEDIA_VIDEO_MASK);
}
base::TimeDelta::FromSecondsD(GetCurrentTime());
#if defined(TIZEN_MULTIMEDIA_ZEROCOPY_SUPPORT)
- gfx::TbmBufferHandle tbm_handle = { tbm_surface, packet };
+ gfx::TbmBufferHandle tbm_handle = { tbm_surface, packet.release() };
manager()->OnNewTbmBufferAvailable(GetPlayerId(), tbm_handle, timestamp);
#else
base::SharedMemory shared_memory;
return;
}
}
- manager()->OnNewFrameAvailable(GetPlayerId(), foreign_memory_handle,
- shared_memory_size, timestamp);
+ manager()->OnNewFrameAvailable(
+ GetPlayerId(), foreign_memory_handle, shared_memory_size, timestamp);
#endif
}
#endif
#include <string>
-#include "base/basictypes.h"
#include "base/callback.h"
#include "base/time/time.h"
-#include "media/base/media_export.h"
-#include "url/gurl.h"
+#include "media/base/efl/media_player_util_efl.h"
typedef struct media_packet_s* media_packet_h;
namespace media {
class MediaPlayerManager;
-struct MediaPacketProxy;
// Error types for MediaErrorCB.
enum MediaErrorType {
int GetPlayerId() { return player_id_; }
- bool IsPlayerDestructing() { return destructing_; }
bool IsPlayerSuspended() { return suspended_; }
virtual void Initialize() {}
virtual void Resume() { suspended_ = false; }
virtual void Suspend() { suspended_ = true; }
- // Destroy this object when all messages for it are delivered
- virtual void Destroy() = 0;
-
-#if defined(TIZEN_TBM_SUPPORT)
- void DestroyMediaPacket(media_packet_h packet);
-#endif
-
protected:
explicit MediaPlayerEfl(int player_id, MediaPlayerManager* manager);
MediaPlayerManager* manager() { return manager_; }
#if defined(TIZEN_TBM_SUPPORT)
- void DeliverMediaPacket(media_packet_h packet);
+ void DeliverMediaPacket(ScopedMediaPacket packet);
#endif
- bool destructing_;
int width_;
int height_;
#include "media/base/efl/media_player_util_efl.h"
+#include <player.h>
+
#include "base/logging.h"
#include "base/time/time.h"
namespace media {
+void MediaPacketDeleter::operator()(media_packet_s* ptr) const {
+ if (ptr != nullptr)
+ media_packet_destroy(ptr);
+}
+
double ConvertNanoSecondsToSeconds(int64 time) {
return base::TimeDelta::FromMicroseconds(
time /
#define MEDIA_BASE_EFL_MEDIA_PLAYER_UTIL_EFL_H_
#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
#include "media/base/media_export.h"
#include "url/gurl.h"
+struct media_packet_s;
+
namespace media {
+struct MediaPacketDeleter {
+ void operator()(media_packet_s* ptr) const;
+};
+
+typedef scoped_ptr<media_packet_s, MediaPacketDeleter> ScopedMediaPacket;
+
typedef enum {
MEDIA_SEEK_NONE, // No seek
MEDIA_SEEK_DEMUXER, // Demuxer seeking
namespace media {
//static
-MediaPlayerEfl* MediaPlayerEfl::CreatePlayer(int player_id, const GURL& url,
- double volume,
- MediaPlayerManager* manager,
- const std::string& user_agent) {
+MediaPlayerEfl* MediaPlayerEfl::CreatePlayer(
+ int player_id, const GURL& url, double volume,
+ MediaPlayerManager* manager, const std::string& ua) {
LOG(INFO) << "MediaElement is using |CAPI| to play media";
- return new MediaPlayerBridgeCapi(player_id, url, volume, manager, user_agent);
+ return new MediaPlayerBridgeCapi(player_id, url, volume, manager, ua);
}
MediaPlayerBridgeCapi::MediaPlayerBridgeCapi(
- int player_id,
- const GURL& url,
- double volume,
- MediaPlayerManager* manager_in,
- const std::string& user_agent)
- : MediaPlayerEfl(player_id, manager_in),
+ int player_id, const GURL& url, double volume,
+ MediaPlayerManager* manager, const std::string& user_agent)
+ : MediaPlayerEfl(player_id, manager),
task_runner_(base::ThreadTaskRunnerHandle::Get()),
player_(NULL),
url_(url),
}
MediaPlayerBridgeCapi::~MediaPlayerBridgeCapi() {
-}
-
-void MediaPlayerBridgeCapi::Destroy() {
- if (IsPlayerDestructing())
- return;
- destructing_ = true;
weak_factory_.InvalidateWeakPtrs();
Release();
player_destroy(player_);
- player_ = NULL;
-
- task_runner_->DeleteSoon(FROM_HERE, this);
}
void MediaPlayerBridgeCapi::Prepare(CompleteCB cb) {
}
void MediaPlayerBridgeCapi::PlayerPrepared() {
- if (IsPlayerDestructing() || GetPlayerState() < PLAYER_STATE_READY) {
+ if (GetPlayerState() < PLAYER_STATE_READY) {
return;
}
}
void MediaPlayerBridgeCapi::OnMediaPacketUpdated(media_packet_h packet) {
+ ScopedMediaPacket packet_proxy(packet);
task_runner_->PostTask(
- FROM_HERE, base::Bind(&MediaPlayerBridgeCapi::DeliverMediaPacket,
- weak_factory_.GetWeakPtr(), packet));
+ FROM_HERE, base::Bind(
+ &MediaPlayerBridgeCapi::DeliverMediaPacket,
+ weak_factory_.GetWeakPtr(), base::Passed(&packet_proxy)));
}
void MediaPlayerBridgeCapi::OnPlaybackCompleteUpdate() {
is_initialized_ = true;
manager()->OnInitComplete(GetPlayerId(), success);
}
+
} // namespace media
void Initialize() override;
void Resume() override;
void Suspend() override;
- void Destroy() override;
void Play() override;
void Pause(bool is_media_related_action) override;
void SetRate(double rate) override;
} // namespace
namespace media {
+
struct ErrorList {
player_error_e error_code;
std::string error_message;
void OnCapiPlayerPreparedCB(void* user_data) {
MediaSourcePlayerCapi* player =
static_cast<MediaSourcePlayerCapi*>(user_data);
- if (player)
- player->OnPrepareComplete();
+ player->OnPrepareComplete();
}
void OnSeekCompleteCB(void* user_data) {
MediaSourcePlayerCapi* player =
static_cast<MediaSourcePlayerCapi*>(user_data);
- if (player)
- player->OnSeekComplete();
+ player->OnSeekComplete();
}
void OnHandleBufferingMessageCB(int percent, void* user_data) {
MediaSourcePlayerCapi* player =
static_cast<MediaSourcePlayerCapi*>(user_data);
- if (!player || player->IsPlayerDestructing())
- return;
player->OnHandleBufferingMessage(percent);
}
void* user_data) {
MediaSourcePlayerCapi* player =
static_cast<MediaSourcePlayerCapi*>(user_data);
- if (!player || player->IsPlayerDestructing())
- return;
if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) {
player->OnUpdateDataStatus(media::DemuxerStream::AUDIO, true);
} else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) {
void* user_data) {
MediaSourcePlayerCapi* player =
static_cast<MediaSourcePlayerCapi*>(user_data);
- if (!player || player->IsPlayerDestructing())
- return;
if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) {
player->OnUpdateDataStatus(media::DemuxerStream::VIDEO, true);
} else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) {
player_prepared_ = true;
manager()->OnReadyStateChange(
GetPlayerId(), blink::WebMediaPlayer::ReadyStateHaveEnoughData);
- manager()->OnNetworkStateChange(GetPlayerId(),
- blink::WebMediaPlayer::NetworkStateLoaded);
+ manager()->OnNetworkStateChange(
+ GetPlayerId(), blink::WebMediaPlayer::NetworkStateLoaded);
}
MediaPlayerEfl* MediaPlayerEfl::CreatePlayer(
}
MediaSourcePlayerCapi::MediaSourcePlayerCapi(
- int player_id, scoped_ptr<DemuxerEfl> demuxer, MediaPlayerManager* manager)
+ int player_id, scoped_ptr<DemuxerEfl> demuxer,
+ MediaPlayerManager* manager)
: MediaPlayerEfl(player_id, manager),
demuxer_(demuxer.Pass()),
task_runner_(base::ThreadTaskRunnerHandle::Get()),
}
}
+MediaSourcePlayerCapi::~MediaSourcePlayerCapi() {
+ Release();
+ player_destroy(player_);
+}
+
void MediaSourcePlayerCapi::SeekComplete() {
DCHECK(task_runner_->BelongsToCurrentThread());
UpdateSeekState(MEDIA_SEEK_NONE);
}
void MediaSourcePlayerCapi::OnMediaPacketUpdated(media_packet_h packet) {
+ ScopedMediaPacket packet_proxy(packet);
task_runner_->PostTask(
- FROM_HERE, base::Bind(&MediaSourcePlayerCapi::DeliverMediaPacket,
- weak_factory_.GetWeakPtr(), packet));
+ FROM_HERE, base::Bind(
+ &MediaSourcePlayerCapi::DeliverMediaPacket,
+ weak_factory_.GetWeakPtr(), base::Passed(&packet_proxy)));
}
void MediaSourcePlayerCapi::SetVolume(double volume) {
#endif
}
-void MediaSourcePlayerCapi::Destroy() {
- if (IsPlayerDestructing())
- return;
-
- destructing_ = true;
- Release();
- player_destroy(player_);
- player_ = NULL;
- task_runner_->DeleteSoon(FROM_HERE, this);
-}
-
// TODO(sam) : It's worked as bypass now. Need Suspend/Resume/Initialize
// implementation for MSE multiple instance.
void MediaSourcePlayerCapi::Initialize() {
}
void MediaSourcePlayerCapi::Release() {
- DCHECK(IsPlayerDestructing());
playing_ = false;
StopCurrentTimeUpdateTimer();
audio_buffer_queue_.clear();
if (width_ > 0 && height_ > 0)
media_type_ |= MEDIA_VIDEO_MASK;
- manager()->OnMediaDataChange(GetPlayerId(), TBM_FORMAT_YUV420, height_,
- width_, media_type_);
+ manager()->OnMediaDataChange(
+ GetPlayerId(), TBM_FORMAT_YUV420, height_, width_, media_type_);
manager()->OnReadyStateChange(
GetPlayerId(), blink::WebMediaPlayer::ReadyStateHaveMetadata);
}
}
- // FIXME(Venu): Need to check where is the exact place for this code.
+ // TODO(Venu): Need to check where is the exact place for this code.
// For make it work added this below code
+ // TODO(max): We have a contradiction here.
+ // To Complete preparing the capi-player, we have to get the first frame
+ // But to get the first frame we have to set readyState to EnoughData,
+ // even we are not ready for play(Setting the Enoughdata make HTML
+ // think that player is ready for play)
+ // We have to make some hack to get/set the first frame without notifying
+ // to HTML.
manager()->OnReadyStateChange(
GetPlayerId(), blink::WebMediaPlayer::ReadyStateHaveEnoughData);
}
void MediaSourcePlayerCapi::ReadDemuxedData(
media::DemuxerStream::Type type) {
- if (IsPlayerDestructing())
- return;
demuxer_->RequestDemuxerData(type);
}
void MediaSourcePlayerCapi::HandleBufferingMessage(int percent) {
- if (IsPlayerDestructing())
- return;
-
// FIXME: add code if required
return;
}
return;
}
- if (IsPlayerDestructing()) {
- LOG(WARNING) << "player deinitializing. Just return";
- return;
- }
-
if (meta_data.status != media::DemuxerStream::kOk ||
meta_data.end_of_stream)
BufferMetaDataAvailable(meta_data);
void MediaSourcePlayerCapi::OnReadDemuxedData(
media::DemuxerStream::Type type) {
- if (IsPlayerDestructing()) {
- LOG(ERROR) << "CAPI player deinitializing. Just return";
- return;
- }
-
task_runner_->PostTask(
FROM_HERE, base::Bind(&MediaSourcePlayerCapi::ReadDemuxedData,
weak_factory_.GetWeakPtr(), type));
void MediaSourcePlayerCapi::OnUpdateDataStatus(
media::DemuxerStream::Type type, bool underflow_status) {
- if (IsPlayerDestructing()) {
- LOG(ERROR) << "CAPI player deinitializing. Just return";
- return;
- }
-
task_runner_->PostTask(
FROM_HERE, base::Bind(&MediaSourcePlayerCapi::HandleUnderFlowStatus,
weak_factory_.GetWeakPtr(),
int player_id, scoped_ptr<DemuxerEfl> demuxer,
MediaPlayerManager* manager);
- ~MediaSourcePlayerCapi() override {};
+ ~MediaSourcePlayerCapi() override;
// MediaPlayerEfl implementation.
void Play() override;
void Seek(const double time) override;
void SetVolume(double volume) override;
double GetCurrentTime() override;
- void Destroy() override;
void Initialize() override;
// DemuxerEflClient implementation.
projects / platform / framework / web / chromium-efl.git / commitdiff