Delete media::Interfaces::ServiceFactory.

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 <vector>
 
@@ skipping 2299 matching lines @@
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableUnifiedMediaPipeline)) {
     // TODO(sandersd): This check should be grown to include HLS and blacklist
     // checks.  http://crbug.com/516765
     return CreateAndroidWebMediaPlayer(client, encrypted_client, params);
   }
 #endif  // defined(OS_ANDROID)
 
 #if defined(ENABLE_MOJO_MEDIA) && !defined(OS_ANDROID)
   scoped_ptr<media::RendererFactory> media_renderer_factory(
-      new media::MojoRendererFactory(GetMediaServiceFactory()));
+      new media::MojoRendererFactory(GetMediaServiceProvider()));
 #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 3206 matching lines @@
   return media_permission->CreateProxy(caller_task_runner).Pass();
 }
 
 media::MediaPermission* RenderFrameImpl::GetMediaPermission() {
   if (!media_permission_dispatcher_)
     media_permission_dispatcher_ = new MediaPermissionDispatcherImpl(this);
   return media_permission_dispatcher_;
 }
 
 #if defined(ENABLE_MOJO_MEDIA)
-media::interfaces::ServiceFactory* RenderFrameImpl::GetMediaServiceFactory() {
-  if (!media_service_factory_) {
-    mojo::ServiceProviderPtr service_provider =
-        ConnectToApplication(GURL("mojo:media"));
-    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_factory_.get();
-}
-
-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();
+mojo::ServiceProvider* RenderFrameImpl::GetMediaServiceProvider() {
+  if (!media_service_provider_)
+    media_service_provider_ = ConnectToApplication(GURL("mojo:media"));
+  return media_service_provider_.get();
 }
 #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(GetMediaServiceFactory()));
+    cdm_factory_.reset(new media::MojoCdmFactory(GetMediaServiceProvider()));
 #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)
   }
@@ skipping 42 matching lines @@
       media::ConvertToSwitchOutputDeviceCB(web_callbacks);
   scoped_refptr<media::AudioOutputDevice> device =
       AudioDeviceFactory::NewOutputDevice(routing_id_, 0, sink_id.utf8(),
                                           security_origin);
   media::OutputDeviceStatus status = device->GetDeviceStatus();
   device->Stop();
   callback.Run(status);
 }
 
 }  // namespace content