media: Add ServiceFactory mojo interface and implementation.

content/renderer/render_frame_impl.cc

 // Copyright 2013 The Chromium Authors. 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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 163 matching lines @@
 
 #if defined(ENABLE_PEPPER_CDMS)
 #include "content/renderer/media/crypto/pepper_cdm_wrapper_impl.h"
 #elif defined(ENABLE_BROWSER_CDMS)
 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
 #endif
 
 #if defined(ENABLE_MOJO_MEDIA)
 #include "media/mojo/services/mojo_cdm_factory.h"
 #include "media/mojo/services/mojo_renderer_factory.h"
+#include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/interfaces/shell.mojom.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
 #else
 #include "media/renderers/default_renderer_factory.h"
 #endif
 
 #if defined(ENABLE_WEBVR)
 #include "content/renderer/vr/vr_dispatcher.h"
 #endif
 
@@ skipping 1830 matching lines @@
                  base::Unretained(GetContentClient()->renderer()),
                  static_cast<RenderFrame*>(this)),
       render_thread->GetAudioRendererMixerManager()->CreateInput(routing_id_),
       media_log, render_thread->GetMediaThreadTaskRunner(),
       render_thread->compositor_task_runner(),
       base::Bind(&GetSharedMainThreadContext3D), GetMediaPermission(),
       initial_cdm);
 
 #if defined(ENABLE_MOJO_MEDIA)
   scoped_ptr<media::RendererFactory> media_renderer_factory(
-      new media::MojoRendererFactory(GetMediaServiceProvider()));
+      new media::MojoRendererFactory(GetMediaServiceFactory()));
 #else
   scoped_ptr<media::RendererFactory> media_renderer_factory =
       GetContentClient()->renderer()->CreateMediaRendererFactory(
           this, render_thread->GetGpuFactories(), media_log);
 
   if (!media_renderer_factory.get()) {
     media_renderer_factory.reset(new media::DefaultRendererFactory(
         media_log, render_thread->GetGpuFactories(),
         *render_thread->GetAudioHardwareConfig()));
   }
@@ skipping 2921 matching lines @@
 
 #endif  // defined(OS_ANDROID)
 
 media::MediaPermission* RenderFrameImpl::GetMediaPermission() {
   if (!media_permission_dispatcher_)
     media_permission_dispatcher_ = new MediaPermissionDispatcher(this);
   return media_permission_dispatcher_;
 }
 
 #if defined(ENABLE_MOJO_MEDIA)
-mojo::ServiceProvider* RenderFrameImpl::GetMediaServiceProvider() {
-  if (!media_service_provider_) {
+media::interfaces::ServiceFactory* RenderFrameImpl::GetMediaServiceFactory() {
+  if (!media_service_factory_) {
     mojo::InterfacePtr<mojo::Shell> shell_ptr;
     GetServiceRegistry()->ConnectToRemoteService(mojo::GetProxy(&shell_ptr));
+
+    mojo::ServiceProviderPtr service_provider;
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From("mojo:media");
-    shell_ptr->ConnectToApplication(
-        request.Pass(), GetProxy(&media_service_provider_), nullptr);
-    media_service_provider_.set_connection_error_handler(
-        base::Bind(&RenderFrameImpl::OnMediaServiceProviderConnectionError,
+    shell_ptr->ConnectToApplication(request.Pass(), GetProxy(&service_provider),

[Ken Rockot(use gerrit already), 2015/07/21 17:29:06]

Hmm this is going to be a recurring pattern. I think I'll put out a follow-up CL
that gives RenderFrame a direct ConnectToApplication interface through a
persistent ShellPtr.

[xhwang, 2015/07/21 22:30:54]

Acknowledged.

+                                    nullptr);
+
+    mojo::ConnectToService(service_provider.get(), &media_service_factory_);
+
+    media_service_factory_.set_connection_error_handler(
+        base::Bind(&RenderFrameImpl::OnMediaServiceFactoryConnectionError,
                    base::Unretained(this)));
   }
-  return media_service_provider_.get();
+
+  return media_service_factory_.get();
 }
 
-void RenderFrameImpl::OnMediaServiceProviderConnectionError() {
-  media_service_provider_.reset();
+void RenderFrameImpl::OnMediaServiceFactoryConnectionError() {
+  // TODO(xhwang): Resetting |media_service_factory_| could cause access
+  // violation on the old |media_service_factory_| by outstanding
+  // media::CdmFactory or media::RendererFactory. Find a better way to handle
+  // this.
+  // media_service_factory_.reset();
 }
 #endif
 
 bool RenderFrameImpl::AreSecureCodecsSupported() {
 #if defined(OS_ANDROID)
   // Hardware-secure codecs are only supported if secure surfaces are enabled.
   return render_view_->renderer_preferences_
       .use_video_overlay_for_embedded_encrypted_video;
 #else
   return false;
 #endif  // defined(OS_ANDROID)
 }
 
 media::CdmFactory* RenderFrameImpl::GetCdmFactory() {
 #if defined(ENABLE_BROWSER_CDMS)
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
   if (!cdm_factory_) {
     DCHECK(frame_);
 
 #if defined(ENABLE_MOJO_MEDIA)
-    cdm_factory_.reset(new media::MojoCdmFactory(GetMediaServiceProvider()));
+    cdm_factory_.reset(new media::MojoCdmFactory(GetMediaServiceFactory()));
 #else
     cdm_factory_.reset(new RenderCdmFactory(
 #if defined(ENABLE_PEPPER_CDMS)
         base::Bind(&PepperCdmWrapperImpl::Create, frame_)
 #elif defined(ENABLE_BROWSER_CDMS)
         cdm_manager_
 #endif
         ));
 #endif  //  defined(ENABLE_MOJO_MEDIA)
   }
 
   return cdm_factory_.get();
 }
 
 void RenderFrameImpl::RegisterMojoServices() {
   // Only main frame have ImageDownloader service.
   if (!frame_->parent()) {
     GetServiceRegistry()->AddService<image_downloader::ImageDownloader>(
         base::Bind(&ImageDownloaderImpl::CreateMojoService,
                    base::Unretained(this)));
   }
 }
 
 }  // namespace content