media: Add ServiceFactory mojo interface and implementation.

ServiceFactory is an interface used to create media services. Services created
in one factory instance are isolated from services created in another factory
instance. This is used in Chromium to isolate media services for different
RenderFrames.

BUG=510653
TEST=Plays the same EME test page in 2 tabs.

Review URL: https://codereview.chromium.org/1230313010

Cr-Commit-Position: refs/heads/master@{#339780}

components/html_viewer/media_factory.cc

@@ -26,6 +26,7 @@
 #include "media/mojo/services/mojo_renderer_factory.h"
 #include "media/renderers/default_renderer_factory.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
+#include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/interfaces/shell.mojom.h"
 
 namespace html_viewer {
@@ -83,7 +84,7 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
 
   if (enable_mojo_media_renderer_) {
     media_renderer_factory.reset(
-        new media::MojoRendererFactory(GetMediaServiceProvider()));
+        new media::MojoRendererFactory(GetMediaServiceFactory()));
   } else {
     media_renderer_factory.reset(
         new media::DefaultRendererFactory(media_log,
@@ -113,15 +114,17 @@ blink::WebEncryptedMediaClient* MediaFactory::GetEncryptedMediaClient() {
   return web_encrypted_media_client_.get();
 }
 
-mojo::ServiceProvider* MediaFactory::GetMediaServiceProvider() {
-  if (!media_service_provider_) {
+media::interfaces::ServiceFactory* MediaFactory::GetMediaServiceFactory() {
+  if (!media_service_factory_) {
+    mojo::ServiceProviderPtr service_provider;
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From("mojo:media");
-    shell_->ConnectToApplication(request.Pass(),
-                                 GetProxy(&media_service_provider_), nullptr);
+    shell_->ConnectToApplication(request.Pass(), GetProxy(&service_provider),
+                                 nullptr);
+    mojo::ConnectToService(service_provider.get(), &media_service_factory_);
   }
 
-  return media_service_provider_.get();
+  return media_service_factory_.get();
 }
 
 media::MediaPermission* MediaFactory::GetMediaPermission() {
@@ -137,7 +140,7 @@ media::MediaPermission* MediaFactory::GetMediaPermission() {
 media::CdmFactory* MediaFactory::GetCdmFactory() {
   if (!cdm_factory_) {
     if (enable_mojo_media_renderer_)
-      cdm_factory_.reset(new media::MojoCdmFactory(GetMediaServiceProvider()));
+      cdm_factory_.reset(new media::MojoCdmFactory(GetMediaServiceFactory()));
     else
       cdm_factory_.reset(new media::DefaultCdmFactory());
   }

components/html_viewer/media_factory.h

@@ -11,6 +11,7 @@
 #include "base/threading/thread.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/base/audio_hardware_config.h"
+#include "media/mojo/interfaces/service_factory.mojom.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 
 namespace base {
@@ -63,7 +64,7 @@ class MediaFactory {
   blink::WebEncryptedMediaClient* GetEncryptedMediaClient();
 
  private:
-  mojo::ServiceProvider* GetMediaServiceProvider();
+  media::interfaces::ServiceFactory* GetMediaServiceFactory();
   media::MediaPermission* GetMediaPermission();
   media::CdmFactory* GetCdmFactory();
 
@@ -83,7 +84,7 @@ class MediaFactory {
   mojo::Shell* shell_;
 
   // Lazily initialized objects.
-  mojo::ServiceProviderPtr media_service_provider_;
+  media::interfaces::ServiceFactoryPtr media_service_factory_;
   scoped_ptr<media::WebEncryptedMediaClientImpl> web_encrypted_media_client_;
   scoped_ptr<media::MediaPermission> media_permission_;
   scoped_ptr<media::CdmFactory> cdm_factory_;

content/renderer/render_frame_impl.cc

@@ -182,6 +182,7 @@
 #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
@@ -2032,7 +2033,7 @@ blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer(
 
 #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(
@@ -4986,23 +4987,33 @@ media::MediaPermission* RenderFrameImpl::GetMediaPermission() {
 }
 
 #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),
+                                    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
 
@@ -5026,7 +5037,7 @@ media::CdmFactory* RenderFrameImpl::GetCdmFactory() {
     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)

content/renderer/render_frame_impl.h

@@ -42,6 +42,10 @@
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #endif
 
+#if defined(ENABLE_MOJO_MEDIA)
+#include "media/mojo/interfaces/service_factory.mojom.h"
+#endif
+
 class GURL;
 class TransportDIB;
 struct FrameMsg_NewFrame_WidgetParams;
@@ -817,10 +821,10 @@ class CONTENT_EXPORT RenderFrameImpl
   media::MediaPermission* GetMediaPermission();
 
 #if defined(ENABLE_MOJO_MEDIA)
-  mojo::ServiceProvider* GetMediaServiceProvider();
+  media::interfaces::ServiceFactory* GetMediaServiceFactory();
 
-  // Called when a connection error happened on |media_service_provider_|.
-  void OnMediaServiceProviderConnectionError();
+  // Called when a connection error happened on |media_service_factory_|.
+  void OnMediaServiceFactoryConnectionError();
 #endif
 
   media::CdmFactory* GetCdmFactory();
@@ -933,8 +937,8 @@ class CONTENT_EXPORT RenderFrameImpl
   MediaPermissionDispatcher* media_permission_dispatcher_;
 
 #if defined(ENABLE_MOJO_MEDIA)
-  // The media service provider attached to this frame, lazily initialized.
-  mojo::ServiceProviderPtr media_service_provider_;
+  // The media factory attached to this frame, lazily initialized.
+  media::interfaces::ServiceFactoryPtr media_service_factory_;
 #endif
 
   // MidiClient attached to this frame; lazily initialized.

media/mojo/interfaces/BUILD.gn

@@ -11,6 +11,7 @@ mojom("interfaces") {
     "demuxer_stream.mojom",
     "media_renderer.mojom",
     "media_types.mojom",
+    "service_factory.mojom",
   ]
 
   if (is_chromeos) {

media/mojo/interfaces/service_factory.mojom

+// Copyright 2015 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.
+
+module media.interfaces;
+
+import "media/mojo/interfaces/content_decryption_module.mojom";
+import "media/mojo/interfaces/media_renderer.mojom";
+
+// A factory interface to create media services. MediaRenderers can only access
+// ContentDecryptionModules created in the same factory.
+interface ServiceFactory {
+  // Creates a ContentDecryptionModule service.
+  CreateCdm(ContentDecryptionModule& cdm);
+
+  // Creates a MediaRenderer service.
+  CreateRenderer(MediaRenderer& renderer);
+};

media/mojo/services/BUILD.gn

@@ -144,6 +144,8 @@ source_set("application") {
   sources = [
     "mojo_media_application.cc",
     "mojo_media_application.h",
+    "service_factory_impl.cc",
+    "service_factory_impl.h",
   ]
 
   public_configs = [ ":enable_mojo_media_config" ]

media/mojo/services/media_apptest.cc

@@ -13,6 +13,7 @@
 #include "media/cdm/key_system_names.h"
 #include "media/mojo/interfaces/content_decryption_module.mojom.h"
 #include "media/mojo/interfaces/media_renderer.mojom.h"
+#include "media/mojo/interfaces/service_factory.mojom.h"
 #include "media/mojo/services/media_type_converters.h"
 #include "media/mojo/services/mojo_demuxer_stream_impl.h"
 #include "mojo/application/public/cpp/application_connection.h"
@@ -61,8 +62,9 @@ class MediaAppTest : public mojo::test::ApplicationTestBase {
     mojo::ApplicationConnection* connection =
         application_impl()->ConnectToApplication(request.Pass());
 
-    connection->ConnectToService(&cdm_);
-    connection->ConnectToService(&media_renderer_);
+    connection->ConnectToService(&service_factory_);
+    service_factory_->CreateCdm(mojo::GetProxy(&cdm_));
+    service_factory_->CreateRenderer(mojo::GetProxy(&media_renderer_));
 
     run_loop_.reset(new base::RunLoop());
   }
@@ -106,6 +108,7 @@ class MediaAppTest : public mojo::test::ApplicationTestBase {
  protected:
   scoped_ptr<base::RunLoop> run_loop_;
 
+  interfaces::ServiceFactoryPtr service_factory_;
   interfaces::ContentDecryptionModulePtr cdm_;
   interfaces::MediaRendererPtr media_renderer_;
 

media/mojo/services/mojo_cdm_factory.cc

@@ -4,14 +4,16 @@
 
 #include "media/mojo/services/mojo_cdm_factory.h"
 
+#include "media/mojo/interfaces/service_factory.mojom.h"
 #include "media/mojo/services/mojo_cdm.h"
 #include "mojo/application/public/cpp/connect.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
 
 namespace media {
 
-MojoCdmFactory::MojoCdmFactory(mojo::ServiceProvider* service_provider)
-    : service_provider_(service_provider) {
-  DCHECK(service_provider_);
+MojoCdmFactory::MojoCdmFactory(interfaces::ServiceFactory* service_factory)
+    : service_factory_(service_factory) {
+  DCHECK(service_factory_);
 }
 
 MojoCdmFactory::~MojoCdmFactory() {
@@ -28,10 +30,10 @@ void MojoCdmFactory::Create(
     const SessionExpirationUpdateCB& session_expiration_update_cb,
     const CdmCreatedCB& cdm_created_cb) {
   DVLOG(2) << __FUNCTION__ << ": " << key_system;
-  DCHECK(service_provider_);
+  DCHECK(service_factory_);
 
   interfaces::ContentDecryptionModulePtr cdm_ptr;
-  mojo::ConnectToService(service_provider_, &cdm_ptr);
+  service_factory_->CreateCdm(mojo::GetProxy(&cdm_ptr));
 
   MojoCdm::Create(key_system, security_origin, cdm_config, cdm_ptr.Pass(),
                   session_message_cb, session_closed_cb,

media/mojo/services/mojo_cdm_factory.h

@@ -8,15 +8,15 @@
 #include "base/macros.h"
 #include "media/base/cdm_factory.h"
 
-namespace mojo {
-class ServiceProvider;
-}
-
 namespace media {
 
+namespace interfaces {
+class ServiceFactory;
+}
+
 class MojoCdmFactory : public CdmFactory {
  public:
-  explicit MojoCdmFactory(mojo::ServiceProvider* service_provider);
+  explicit MojoCdmFactory(interfaces::ServiceFactory* service_factory);
   ~MojoCdmFactory() final;
 
   // CdmFactory implementation.
@@ -31,7 +31,7 @@ class MojoCdmFactory : public CdmFactory {
               const CdmCreatedCB& cdm_created_cb) final;
 
  private:
-  mojo::ServiceProvider* service_provider_;
+  interfaces::ServiceFactory* service_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoCdmFactory);
 };

media/mojo/services/mojo_cdm_service.cc

@@ -21,7 +21,7 @@ using NewSessionMojoCdmPromise = MojoCdmPromise<std::string>;
 using SimpleMojoCdmPromise = MojoCdmPromise<>;
 
 MojoCdmService::MojoCdmService(
-    MojoCdmServiceContext* context,
+    base::WeakPtr<MojoCdmServiceContext> context,
     mojo::ServiceProvider* service_provider,
     CdmFactory* cdm_factory,
     mojo::InterfaceRequest<interfaces::ContentDecryptionModule> request)
@@ -36,7 +36,7 @@ MojoCdmService::MojoCdmService(
 }
 
 MojoCdmService::~MojoCdmService() {
-  if (cdm_id_ != CdmContext::kInvalidCdmId)
+  if (cdm_id_ != CdmContext::kInvalidCdmId && context_)
     context_->UnregisterCdm(cdm_id_);
 }
 
@@ -142,7 +142,7 @@ void MojoCdmService::OnCdmCreated(int cdm_id,
                                   const std::string& error_message) {
   // TODO(xhwang): This should not happen when KeySystemInfo is properly
   // populated. See http://crbug.com/469366
-  if (!cdm) {
+  if (!cdm || !context_) {
     promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, error_message);
     return;
   }

media/mojo/services/mojo_cdm_service.h

@@ -12,13 +12,13 @@
 #include "media/base/media_keys.h"
 #include "media/mojo/interfaces/content_decryption_module.mojom.h"
 #include "media/mojo/services/mojo_cdm_promise.h"
+#include "media/mojo/services/mojo_cdm_service_context.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace media {
 
 class CdmFactory;
-class MojoCdmServiceContext;
 
 // A interfaces::ContentDecryptionModule implementation backed by a
 // media::MediaKeys.
@@ -26,7 +26,7 @@ class MojoCdmService : public interfaces::ContentDecryptionModule {
  public:
   // Constructs a MojoCdmService and strongly binds it to the |request|.
   MojoCdmService(
-      MojoCdmServiceContext* context,
+      base::WeakPtr<MojoCdmServiceContext> context,
       mojo::ServiceProvider* service_provider,
       CdmFactory* cdm_factory,
       mojo::InterfaceRequest<interfaces::ContentDecryptionModule> request);
@@ -98,7 +98,8 @@ class MojoCdmService : public interfaces::ContentDecryptionModule {
                             const std::string& error_message);
 
   mojo::StrongBinding<interfaces::ContentDecryptionModule> binding_;
-  MojoCdmServiceContext* context_;
+  base::WeakPtr<MojoCdmServiceContext> context_;
+
   mojo::ServiceProvider* service_provider_;
   CdmFactory* cdm_factory_;
   scoped_ptr<MediaKeys> cdm_;

media/mojo/services/mojo_cdm_service_context.cc

@@ -6,15 +6,19 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "media/mojo/services/mojo_cdm_service.h"
 
 namespace media {
 
-MojoCdmServiceContext::MojoCdmServiceContext() {
-}
+MojoCdmServiceContext::MojoCdmServiceContext() : weak_ptr_factory_(this) {}
 
 MojoCdmServiceContext::~MojoCdmServiceContext() {
 }
 
+base::WeakPtr<MojoCdmServiceContext> MojoCdmServiceContext::GetWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
 void MojoCdmServiceContext::RegisterCdm(int cdm_id,
                                         MojoCdmService* cdm_service) {
   DCHECK(!cdm_services_.count(cdm_id));

media/mojo/services/mojo_cdm_service_context.h

@@ -5,20 +5,25 @@
 #ifndef MEDIA_MOJO_SERVICES_MOJO_CDM_SERVICE_CONTEXT_H_
 #define MEDIA_MOJO_SERVICES_MOJO_CDM_SERVICE_CONTEXT_H_
 
-#include "base/containers/scoped_ptr_hash_map.h"
+#include <map>
+
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "media/base/cdm_context.h"
 #include "media/base/media_export.h"
-#include "media/mojo/services/mojo_cdm_service.h"
 
 namespace media {
 
+class MojoCdmService;
+
 // A class that creates, owns and manages all MojoCdmService instances.
 class MEDIA_EXPORT MojoCdmServiceContext : public CdmContextProvider {
  public:
   MojoCdmServiceContext();
   ~MojoCdmServiceContext() override;
 
+  base::WeakPtr<MojoCdmServiceContext> GetWeakPtr();
+
   // Registers The |cdm_service| with |cdm_id|.
   void RegisterCdm(int cdm_id, MojoCdmService* cdm_service);
 
@@ -36,6 +41,9 @@ class MEDIA_EXPORT MojoCdmServiceContext : public CdmContextProvider {
   // A map between CDM ID and MojoCdmService.
   std::map<int, MojoCdmService*> cdm_services_;
 
+  // NOTE: Weak pointers must be invalidated before all other member variables.
+  base::WeakPtrFactory<MojoCdmServiceContext> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(MojoCdmServiceContext);
 };
 

media/mojo/services/mojo_media_application.cc

@@ -5,12 +5,8 @@
 #include "media/mojo/services/mojo_media_application.h"
 
 #include "base/logging.h"
-#include "media/base/cdm_factory.h"
 #include "media/base/media_log.h"
-#include "media/base/renderer_factory.h"
-#include "media/mojo/services/mojo_cdm_service.h"
-#include "media/mojo/services/mojo_media_client.h"
-#include "media/mojo/services/mojo_renderer_service.h"
+#include "media/mojo/services/service_factory_impl.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 
@@ -45,38 +41,16 @@ void MojoMediaApplication::Initialize(mojo::ApplicationImpl* app) {
 
 bool MojoMediaApplication::ConfigureIncomingConnection(
     mojo::ApplicationConnection* connection) {
-  connection->AddService<interfaces::ContentDecryptionModule>(this);
-  connection->AddService<interfaces::MediaRenderer>(this);
+  connection->AddService<interfaces::ServiceFactory>(this);
   return true;
 }
 
 void MojoMediaApplication::Create(
     mojo::ApplicationConnection* connection,
-    mojo::InterfaceRequest<interfaces::ContentDecryptionModule> request) {
+    mojo::InterfaceRequest<interfaces::ServiceFactory> request) {
   // The created object is owned by the pipe.
-  new MojoCdmService(&cdm_service_context_, connection->GetServiceProvider(),
-                     GetCdmFactory(), request.Pass());
-}
-
-void MojoMediaApplication::Create(
-    mojo::ApplicationConnection* connection,
-    mojo::InterfaceRequest<interfaces::MediaRenderer> request) {
-  // The created object is owned by the pipe.
-  new MojoRendererService(&cdm_service_context_, GetRendererFactory(),
-                          media_log_, request.Pass());
-}
-
-RendererFactory* MojoMediaApplication::GetRendererFactory() {
-  if (!renderer_factory_)
-    renderer_factory_ =
-        MojoMediaClient::Get()->CreateRendererFactory(media_log_);
-  return renderer_factory_.get();
-}
-
-CdmFactory* MojoMediaApplication::GetCdmFactory() {
-  if (!cdm_factory_)
-    cdm_factory_ = MojoMediaClient::Get()->CreateCdmFactory();
-  return cdm_factory_.get();
+  new ServiceFactoryImpl(request.Pass(), connection->GetServiceProvider(),
+                         media_log_);
 }
 
 }  // namespace media

media/mojo/services/mojo_media_application.h

@@ -2,24 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/memory/scoped_ptr.h"
-#include "media/mojo/interfaces/content_decryption_module.mojom.h"
-#include "media/mojo/interfaces/media_renderer.mojom.h"
-#include "media/mojo/services/mojo_cdm_service_context.h"
+#include "base/memory/ref_counted.h"
+#include "media/mojo/interfaces/service_factory.mojom.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/interface_factory_impl.h"
 #include "url/gurl.h"
 
 namespace media {
 
-class CdmFactory;
 class MediaLog;
-class RendererFactory;
 
 class MojoMediaApplication
     : public mojo::ApplicationDelegate,
-      public mojo::InterfaceFactory<interfaces::ContentDecryptionModule>,
-      public mojo::InterfaceFactory<interfaces::MediaRenderer> {
+      public mojo::InterfaceFactory<interfaces::ServiceFactory> {
  public:
   static GURL AppUrl();
   static scoped_ptr<mojo::ApplicationDelegate> CreateApp();
@@ -33,21 +28,10 @@ class MojoMediaApplication
   bool ConfigureIncomingConnection(
       mojo::ApplicationConnection* connection) final;
 
-  // mojo::InterfaceFactory<interfaces::ContentDecryptionModule> implementation.
+  // mojo::InterfaceFactory<interfaces::ServiceFactory> implementation.
   void Create(mojo::ApplicationConnection* connection,
-              mojo::InterfaceRequest<interfaces::ContentDecryptionModule>
-                  request) final;
+              mojo::InterfaceRequest<interfaces::ServiceFactory> request) final;
 
-  // mojo::InterfaceFactory<interfaces::MediaRenderer> implementation.
-  void Create(mojo::ApplicationConnection* connection,
-              mojo::InterfaceRequest<interfaces::MediaRenderer> request) final;
-
-  RendererFactory* GetRendererFactory();
-  CdmFactory* GetCdmFactory();
-
-  MojoCdmServiceContext cdm_service_context_;
-  scoped_ptr<RendererFactory> renderer_factory_;
-  scoped_ptr<CdmFactory> cdm_factory_;
   scoped_refptr<MediaLog> media_log_;
 };
 

media/mojo/services/mojo_renderer_factory.cc

@@ -5,15 +5,16 @@
 #include "media/mojo/services/mojo_renderer_factory.h"
 
 #include "base/single_thread_task_runner.h"
+#include "media/mojo/interfaces/service_factory.mojom.h"
 #include "media/mojo/services/mojo_renderer_impl.h"
-#include "mojo/application/public/cpp/connect.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
 
 namespace media {
 
 MojoRendererFactory::MojoRendererFactory(
-    mojo::ServiceProvider* service_provider)
-    : service_provider_(service_provider) {
-  DCHECK(service_provider_);
+    interfaces::ServiceFactory* service_factory)
+    : service_factory_(service_factory) {
+  DCHECK(service_factory_);
 }
 
 MojoRendererFactory::~MojoRendererFactory() {
@@ -23,10 +24,10 @@ scoped_ptr<Renderer> MojoRendererFactory::CreateRenderer(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     AudioRendererSink* /* audio_renderer_sink */,
     VideoRendererSink* /* video_renderer_sink */) {
-  DCHECK(service_provider_);
+  DCHECK(service_factory_);
 
   interfaces::MediaRendererPtr mojo_media_renderer;
-  mojo::ConnectToService(service_provider_, &mojo_media_renderer);
+  service_factory_->CreateRenderer(mojo::GetProxy(&mojo_media_renderer));
 
   return scoped_ptr<Renderer>(
       new MojoRendererImpl(media_task_runner, mojo_media_renderer.Pass()));

media/mojo/services/mojo_renderer_factory.h

@@ -10,16 +10,16 @@
 #include "media/mojo/interfaces/media_renderer.mojom.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_ptr.h"
 
-namespace mojo {
-class ServiceProvider;
-}
-
 namespace media {
 
+namespace interfaces {
+class ServiceFactory;
+}
+
 // The default factory class for creating MojoRendererImpl.
 class MEDIA_EXPORT MojoRendererFactory : public RendererFactory {
  public:
-  explicit MojoRendererFactory(mojo::ServiceProvider* service_provider);
+  explicit MojoRendererFactory(interfaces::ServiceFactory* service_factory);
   ~MojoRendererFactory() final;
 
   scoped_ptr<Renderer> CreateRenderer(
@@ -28,7 +28,7 @@ class MEDIA_EXPORT MojoRendererFactory : public RendererFactory {
       VideoRendererSink* video_renderer_sink) final;
 
  private:
-  mojo::ServiceProvider* service_provider_;
+  interfaces::ServiceFactory* service_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoRendererFactory);
 };

media/mojo/services/mojo_renderer_service.cc

@@ -29,7 +29,7 @@ namespace media {
 const int kTimeUpdateIntervalMs = 50;
 
 MojoRendererService::MojoRendererService(
-    CdmContextProvider* cdm_context_provider,
+    base::WeakPtr<CdmContextProvider> cdm_context_provider,
     RendererFactory* renderer_factory,
     const scoped_refptr<MediaLog>& media_log,
     mojo::InterfaceRequest<interfaces::MediaRenderer> request)

media/mojo/services/mojo_renderer_service.h

@@ -16,6 +16,7 @@
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
 #include "media/mojo/interfaces/media_renderer.mojom.h"
+#include "media/mojo/services/mojo_cdm_service_context.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
 
 namespace mojo {
@@ -40,7 +41,7 @@ class MEDIA_EXPORT MojoRendererService
   // |cdm_context_provider| can be used to find the CdmContext to support
   // encrypted media. If null, encrypted media is not supported.
   MojoRendererService(
-      CdmContextProvider* cdm_context_provider,
+      base::WeakPtr<CdmContextProvider> cdm_context_provider,
       RendererFactory* renderer_factory,
       const scoped_refptr<MediaLog>& media_log,
       mojo::InterfaceRequest<interfaces::MediaRenderer> request);
@@ -102,7 +103,7 @@ class MEDIA_EXPORT MojoRendererService
 
   mojo::StrongBinding<interfaces::MediaRenderer> binding_;
 
-  CdmContextProvider* cdm_context_provider_;
+  base::WeakPtr<CdmContextProvider> cdm_context_provider_;
 
   State state_;
 

media/mojo/services/service_factory_impl.cc

+// Copyright 2015 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 "media/mojo/services/service_factory_impl.h"
+
+#include "base/logging.h"
+#include "media/base/cdm_factory.h"
+#include "media/base/media_log.h"
+#include "media/base/renderer_factory.h"
+#include "media/mojo/services/mojo_cdm_service.h"
+#include "media/mojo/services/mojo_media_client.h"
+#include "media/mojo/services/mojo_renderer_service.h"
+
+namespace media {
+
+ServiceFactoryImpl::ServiceFactoryImpl(
+    mojo::InterfaceRequest<interfaces::ServiceFactory> request,
+    mojo::ServiceProvider* service_provider,
+    scoped_refptr<MediaLog> media_log)
+    : binding_(this, request.Pass()),
+      service_provider_(service_provider),
+      media_log_(media_log) {
+  DVLOG(1) << __FUNCTION__;
+}
+
+ServiceFactoryImpl::~ServiceFactoryImpl() {
+  DVLOG(1) << __FUNCTION__;
+}
+
+// interfaces::ServiceFactory implementation.
+void ServiceFactoryImpl::CreateRenderer(
+    mojo::InterfaceRequest<interfaces::MediaRenderer> request) {
+  // The created object is owned by the pipe.
+  new MojoRendererService(cdm_service_context_.GetWeakPtr(),
+                          GetRendererFactory(), media_log_, request.Pass());
+}
+
+void ServiceFactoryImpl::CreateCdm(
+    mojo::InterfaceRequest<interfaces::ContentDecryptionModule> request) {
+  // The created object is owned by the pipe.
+  new MojoCdmService(cdm_service_context_.GetWeakPtr(), service_provider_,
+                     GetCdmFactory(), request.Pass());
+}
+
+RendererFactory* ServiceFactoryImpl::GetRendererFactory() {
+  if (!renderer_factory_)
+    renderer_factory_ =
+        MojoMediaClient::Get()->CreateRendererFactory(media_log_);
+  return renderer_factory_.get();
+}
+
+CdmFactory* ServiceFactoryImpl::GetCdmFactory() {
+  if (!cdm_factory_)
+    cdm_factory_ = MojoMediaClient::Get()->CreateCdmFactory();
+  return cdm_factory_.get();
+}
+
+}  // namespace media

media/mojo/services/service_factory_impl.h

+// Copyright 2015 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.
+
+#ifndef MEDIA_MOJO_SERVICES_SERVICE_FACTORY_IMPL_H_
+#define MEDIA_MOJO_SERVICES_SERVICE_FACTORY_IMPL_H_
+
+#include "base/macros.h"
+#include "media/mojo/interfaces/service_factory.mojom.h"
+#include "media/mojo/services/mojo_cdm_service_context.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+
+namespace mojo {
+class ServiceProvider;
+}
+
+namespace media {
+
+class CdmFactory;
+class MediaLog;
+class RendererFactory;
+
+class ServiceFactoryImpl : public interfaces::ServiceFactory {
+ public:
+  ServiceFactoryImpl(mojo::InterfaceRequest<interfaces::ServiceFactory> request,
+                     mojo::ServiceProvider* service_provider,
+                     scoped_refptr<MediaLog> media_log);
+  ~ServiceFactoryImpl() final;
+
+  // interfaces::ServiceFactory implementation.
+  void CreateRenderer(
+      mojo::InterfaceRequest<interfaces::MediaRenderer> renderer) final;
+  void CreateCdm(
+      mojo::InterfaceRequest<interfaces::ContentDecryptionModule> cdm) final;
+
+ private:
+  RendererFactory* GetRendererFactory();
+  CdmFactory* GetCdmFactory();
+
+  MojoCdmServiceContext cdm_service_context_;
+
+  mojo::StrongBinding<interfaces::ServiceFactory> binding_;
+  mojo::ServiceProvider* service_provider_;
+  scoped_refptr<MediaLog> media_log_;
+
+  scoped_ptr<RendererFactory> renderer_factory_;
+  scoped_ptr<CdmFactory> cdm_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ServiceFactoryImpl);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_MOJO_SERVICES_SERVICE_FACTORY_IMPL_H_

media/test/pipeline_integration_test.cc

@@ -26,6 +26,8 @@
 #include "url/gurl.h"
 
 #if defined(MOJO_RENDERER)
+#include "media/mojo/interfaces/media_renderer.mojom.h"
+#include "media/mojo/interfaces/service_factory.mojom.h"
 #include "media/mojo/services/mojo_renderer_impl.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
@@ -619,11 +621,18 @@ class PipelineIntegrationTestHost : public mojo::test::ApplicationTestBase,
             ->ConnectToApplication(request.Pass())
             ->GetServiceProvider();
 
+    mojo::ConnectToService(service_provider, &media_service_factory_);
+
     interfaces::MediaRendererPtr mojo_media_renderer;
-    mojo::ConnectToService(service_provider, &mojo_media_renderer);
+    media_service_factory_->CreateRenderer(
+        mojo::GetProxy(&mojo_media_renderer));
+
     return make_scoped_ptr(new MojoRendererImpl(message_loop_.task_runner(),
                                                 mojo_media_renderer.Pass()));
   }
+
+ private:
+  interfaces::ServiceFactoryPtr media_service_factory_;
 };
 #else
 class PipelineIntegrationTestHost : public testing::Test,