src/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              ->GetMessageLoop()
  58              ->message_loop_proxy()
  59              ->BelongsToCurrentThread());
  60
  61   io_message_loop_proxy_->PostTask(
  62       FROM_HERE,
  63       base::Bind(&CastSessionDelegate::StartAudio,
  64                  base::Unretained(delegate_.get()),
  65                  config,
  66                  media::BindToCurrentLoop(callback),
  67                  media::BindToCurrentLoop(error_callback)));
  68 }
  69
  70 void CastSession::StartVideo(const media::cast::VideoSenderConfig& config,
  71                              const VideoFrameInputAvailableCallback& callback,
  72                              const ErrorCallback& error_callback) {
  73   DCHECK(content::RenderThread::Get()
  74              ->GetMessageLoop()
  75              ->message_loop_proxy()
  76              ->BelongsToCurrentThread());
  77
  78   io_message_loop_proxy_->PostTask(
  79       FROM_HERE,
  80       base::Bind(&CastSessionDelegate::StartVideo,
  81                  base::Unretained(delegate_.get()),
  82                  config,
  83                  media::BindToCurrentLoop(callback),
  84                  media::BindToCurrentLoop(error_callback),
  85                  media::BindToCurrentLoop(
  86                      base::Bind(&CreateVideoEncodeAccelerator)),
  87                  media::BindToCurrentLoop(
  88                      base::Bind(&CreateVideoEncodeMemory))));
  89 }
  90
  91 void CastSession::StartUDP(const net::IPEndPoint& remote_endpoint,
  92                            scoped_ptr<base::DictionaryValue> options) {
  93   io_message_loop_proxy_->PostTask(
  94       FROM_HERE,
  95       base::Bind(
  96           &CastSessionDelegate::StartUDP,
  97           base::Unretained(delegate_.get()),
  98           remote_endpoint,
  99           base::Passed(&options)));
 100 }
 101
 102 void CastSession::ToggleLogging(bool is_audio, bool enable) {
 103   io_message_loop_proxy_->PostTask(
 104       FROM_HERE,
 105       base::Bind(&CastSessionDelegate::ToggleLogging,
 106                  base::Unretained(delegate_.get()),
 107                  is_audio,
 108                  enable));
 109 }
 110
 111 void CastSession::GetEventLogsAndReset(
 112     bool is_audio, const std::string& extra_data,
 113     const EventLogsCallback& callback) {
 114   io_message_loop_proxy_->PostTask(
 115       FROM_HERE,
 116       base::Bind(&CastSessionDelegate::GetEventLogsAndReset,
 117                  base::Unretained(delegate_.get()),
 118                  is_audio,
 119                  extra_data,
 120                  media::BindToCurrentLoop(callback)));
 121 }
 122
 123 void CastSession::GetStatsAndReset(bool is_audio,
 124                                    const StatsCallback& callback) {
 125   io_message_loop_proxy_->PostTask(
 126       FROM_HERE,
 127       base::Bind(&CastSessionDelegate::GetStatsAndReset,
 128                  base::Unretained(delegate_.get()),
 129                  is_audio,
 130                  media::BindToCurrentLoop(callback)));
 131 }