components/html_viewer/media_factory.cc

   1 // Copyright 2014 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 "components/html_viewer/media_factory.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/files/file_path.h"
  10 #include "base/path_service.h"
  11 #include "base/threading/thread.h"
  12 #include "build/build_config.h"
  13 #include "media/audio/audio_manager.h"
  14 #include "media/audio/audio_manager_base.h"
  15 #include "media/audio/audio_output_stream_sink.h"
  16 #include "media/base/audio_hardware_config.h"
  17 #include "media/base/media.h"
  18 #include "media/base/media_log.h"
  19 #include "media/blink/webencryptedmediaclient_impl.h"
  20 #include "media/blink/webmediaplayer_impl.h"
  21 #include "media/blink/webmediaplayer_params.h"
  22 #include "media/cdm/default_cdm_factory.h"
  23 #include "media/filters/default_media_permission.h"
  24 #include "media/mojo/interfaces/media_renderer.mojom.h"
  25 #include "media/mojo/services/mojo_cdm_factory.h"
  26 #include "media/mojo/services/mojo_renderer_factory.h"
  27 #include "media/renderers/default_renderer_factory.h"
  28 #include "media/renderers/gpu_video_accelerator_factories.h"
  29 #include "mojo/application/public/cpp/connect.h"
  30 #include "mojo/application/public/interfaces/shell.mojom.h"
  31
  32 namespace html_viewer {
  33
  34 namespace {
  35
  36 // Enable MediaRenderer in media pipeline instead of using the internal
  37 // media::Renderer implementation.
  38 // TODO(xhwang): Move this to media_switches.h.
  39 const char kEnableMojoMediaRenderer[] = "enable-mojo-media-renderer";
  40
  41 bool AreSecureCodecsSupported() {
  42   // Hardware-secure codecs are not currently supported by HTML Viewer on any
  43   // platform.
  44   return false;
  45 }
  46
  47 }  // namespace
  48
  49 MediaFactory::MediaFactory(
  50     const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
  51     mojo::Shell* shell)
  52     :
  53 #if !defined(OS_ANDROID)
  54       media_thread_("Media"),
  55       audio_manager_(media::AudioManager::Create(&fake_audio_log_factory_)),
  56       audio_hardware_config_(
  57           audio_manager_->GetInputStreamParameters(
  58               media::AudioManagerBase::kDefaultDeviceId),
  59           audio_manager_->GetDefaultOutputStreamParameters()),
  60 #endif
  61       enable_mojo_media_renderer_(base::CommandLine::ForCurrentProcess()
  62                                       ->HasSwitch(kEnableMojoMediaRenderer)),
  63       compositor_task_runner_(compositor_task_runner),
  64       shell_(shell) {
  65   media::InitializeMediaLibrary();
  66 }
  67
  68 MediaFactory::~MediaFactory() {
  69 }
  70
  71 blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
  72     blink::WebLocalFrame* frame,
  73     const blink::WebURL& url,
  74     blink::WebMediaPlayerClient* client,
  75     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
  76     blink::WebContentDecryptionModule* initial_cdm,
  77     mojo::Shell* shell) {
  78 #if defined(OS_ANDROID)
  79   // TODO(xhwang): Get CreateMediaPlayer working on android.
  80   return nullptr;
  81 #else
  82   scoped_refptr<media::MediaLog> media_log(new media::MediaLog());
  83   scoped_ptr<media::RendererFactory> media_renderer_factory;
  84
  85   if (enable_mojo_media_renderer_) {
  86     media_renderer_factory.reset(
  87         new media::MojoRendererFactory(GetMediaServiceFactory()));
  88   } else {
  89     media_renderer_factory.reset(
  90         new media::DefaultRendererFactory(media_log,
  91                                           nullptr,  // No GPU factory.
  92                                           GetAudioHardwareConfig()));
  93   }
  94
  95   media::WebMediaPlayerParams params(
  96       media::WebMediaPlayerParams::DeferLoadCB(), CreateAudioRendererSink(),
  97       media_log, GetMediaThreadTaskRunner(), compositor_task_runner_,
  98       media::WebMediaPlayerParams::Context3DCB(), GetMediaPermission(),
  99       initial_cdm);
 100   base::WeakPtr<media::WebMediaPlayerDelegate> delegate;
 101
 102   return new media::WebMediaPlayerImpl(frame, client, encrypted_client,
 103                                        delegate, media_renderer_factory.Pass(),
 104                                        GetCdmFactory(), params);
 105 #endif  // defined(OS_ANDROID)
 106 }
 107
 108 blink::WebEncryptedMediaClient* MediaFactory::GetEncryptedMediaClient() {
 109   if (!web_encrypted_media_client_) {
 110     web_encrypted_media_client_.reset(new media::WebEncryptedMediaClientImpl(
 111         base::Bind(&AreSecureCodecsSupported), GetCdmFactory(),
 112         GetMediaPermission()));
 113   }
 114   return web_encrypted_media_client_.get();
 115 }
 116
 117 media::interfaces::ServiceFactory* MediaFactory::GetMediaServiceFactory() {
 118   if (!media_service_factory_) {
 119     mojo::ServiceProviderPtr service_provider;
 120     mojo::URLRequestPtr request(mojo::URLRequest::New());
 121     request->url = mojo::String::From("mojo:media");
 122     shell_->ConnectToApplication(request.Pass(), GetProxy(&service_provider),
 123                                  nullptr);
 124     mojo::ConnectToService(service_provider.get(), &media_service_factory_);
 125   }
 126
 127   return media_service_factory_.get();
 128 }
 129
 130 media::MediaPermission* MediaFactory::GetMediaPermission() {
 131   // TODO(xhwang): Replace DefaultMediaPermission with something real when
 132   // permissions are supported in html_viewer.
 133   NOTIMPLEMENTED();
 134
 135   if (!media_permission_)
 136     media_permission_.reset(new media::DefaultMediaPermission(true));
 137   return media_permission_.get();
 138 }
 139
 140 media::CdmFactory* MediaFactory::GetCdmFactory() {
 141   if (!cdm_factory_) {
 142     if (enable_mojo_media_renderer_)
 143       cdm_factory_.reset(new media::MojoCdmFactory(GetMediaServiceFactory()));
 144     else
 145       cdm_factory_.reset(new media::DefaultCdmFactory());
 146   }
 147
 148   return cdm_factory_.get();
 149 }
 150
 151 #if !defined(OS_ANDROID)
 152 const media::AudioHardwareConfig& MediaFactory::GetAudioHardwareConfig() {
 153   return audio_hardware_config_;
 154 }
 155
 156 scoped_refptr<media::AudioRendererSink>
 157 MediaFactory::CreateAudioRendererSink() {
 158   // TODO(dalecurtis): Replace this with an interface to an actual mojo service;
 159   // the AudioOutputStreamSink will not work in sandboxed processes.
 160   return new media::AudioOutputStreamSink();
 161 }
 162
 163 scoped_refptr<base::SingleThreadTaskRunner>
 164 MediaFactory::GetMediaThreadTaskRunner() {
 165   if (!media_thread_.IsRunning())
 166     media_thread_.Start();
 167
 168   return media_thread_.task_runner();
 169 }
 170 #endif  // !defined(OS_ANDROID)
 171
 172 }  // namespace html_viewer