chrome/renderer/media/cast_session.cc

   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 #include "chrome/renderer/media/cast_session.h"
   6
   7 #include "base/message_loop/message_loop_proxy.h"
   8 #include "chrome/renderer/media/cast_session_delegate.h"
   9 #include "content/public/renderer/render_thread.h"
  10 #include "content/public/renderer/video_encode_accelerator.h"
  11 #include "media/base/bind_to_current_loop.h"
  12 #include "media/base/video_frame.h"
  13 #include "media/cast/cast_config.h"
  14 #include "media/cast/cast_sender.h"
  15 #include "media/cast/logging/logging_defines.h"
  16
  17 namespace {
  18
  19 void CreateVideoEncodeAccelerator(
  20     const media::cast::ReceiveVideoEncodeAcceleratorCallback& callback) {
  21   DCHECK(content::RenderThread::Get());
  22
  23   // Delegate the call to content API on the render thread.
  24   content::CreateVideoEncodeAccelerator(callback);
  25 }
  26
  27 void CreateVideoEncodeMemory(
  28     size_t size,
  29     const media::cast::ReceiveVideoEncodeMemoryCallback& callback) {
  30   DCHECK(content::RenderThread::Get());
  31
  32   scoped_ptr<base::SharedMemory> shm =
  33       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(size);
  34   DCHECK(shm) << "Failed to allocate shared memory";
  35   if (!shm->Map(size)) {
  36     NOTREACHED() << "Map failed";
  37   }
  38   callback.Run(shm.Pass());
  39 }
  40
  41 }  // namespace
  42
  43 CastSession::CastSession()
  44     : delegate_(new CastSessionDelegate()),
  45       io_message_loop_proxy_(
  46           content::RenderThread::Get()->GetIOMessageLoopProxy()) {}
  47
  48 CastSession::~CastSession() {
  49   // We should always be able to delete the object on the IO thread.
  50   CHECK(io_message_loop_proxy_->DeleteSoon(FROM_HERE, delegate_.release()));
  51 }
  52
  53 void CastSession::StartAudio(const media::cast::AudioSenderConfig& config,
  54                              const AudioFrameInputAvailableCallback& callback,
  55                              const ErrorCallback& error_callback) {
  56   DCHECK(content::RenderThread::Get()
  57              ->GetTaskRunner()->BelongsToCurrentThread());
  58
  59   io_message_loop_proxy_->PostTask(
  60       FROM_HERE,
  61       base::Bind(&CastSessionDelegate::StartAudio,
  62                  base::Unretained(delegate_.get()),
  63                  config,
  64                  media::BindToCurrentLoop(callback),
  65                  media::BindToCurrentLoop(error_callback)));
  66 }
  67
  68 void CastSession::StartVideo(const media::cast::VideoSenderConfig& config,
  69                              const VideoFrameInputAvailableCallback& callback,
  70                              const ErrorCallback& error_callback) {
  71   DCHECK(content::RenderThread::Get()
  72              ->GetTaskRunner()->BelongsToCurrentThread());
  73
  74   io_message_loop_proxy_->PostTask(
  75       FROM_HERE,
  76       base::Bind(&CastSessionDelegate::StartVideo,
  77                  base::Unretained(delegate_.get()),
  78                  config,
  79                  media::BindToCurrentLoop(callback),
  80                  media::BindToCurrentLoop(error_callback),
  81                  media::BindToCurrentLoop(
  82                      base::Bind(&CreateVideoEncodeAccelerator)),
  83                  media::BindToCurrentLoop(
  84                      base::Bind(&CreateVideoEncodeMemory))));
  85 }
  86
  87 void CastSession::StartUDP(const net::IPEndPoint& remote_endpoint,
  88                            scoped_ptr<base::DictionaryValue> options) {
  89   io_message_loop_proxy_->PostTask(
  90       FROM_HERE,
  91       base::Bind(
  92           &CastSessionDelegate::StartUDP,
  93           base::Unretained(delegate_.get()),
  94           net::IPEndPoint(),
  95           remote_endpoint,
  96           base::Passed(&options)));
  97 }
  98
  99 void CastSession::ToggleLogging(bool is_audio, bool enable) {
 100   io_message_loop_proxy_->PostTask(
 101       FROM_HERE,
 102       base::Bind(&CastSessionDelegate::ToggleLogging,
 103                  base::Unretained(delegate_.get()),
 104                  is_audio,
 105                  enable));
 106 }
 107
 108 void CastSession::GetEventLogsAndReset(
 109     bool is_audio, const std::string& extra_data,
 110     const EventLogsCallback& callback) {
 111   io_message_loop_proxy_->PostTask(
 112       FROM_HERE,
 113       base::Bind(&CastSessionDelegate::GetEventLogsAndReset,
 114                  base::Unretained(delegate_.get()),
 115                  is_audio,
 116                  extra_data,
 117                  media::BindToCurrentLoop(callback)));
 118 }
 119
 120 void CastSession::GetStatsAndReset(bool is_audio,
 121                                    const StatsCallback& callback) {
 122   io_message_loop_proxy_->PostTask(
 123       FROM_HERE,
 124       base::Bind(&CastSessionDelegate::GetStatsAndReset,
 125                  base::Unretained(delegate_.get()),
 126                  is_audio,
 127                  media::BindToCurrentLoop(callback)));
 128 }