Convert MediaLog from being ref counted to owned by WebMediaPlayer.

chromecast/media/service/cast_mojo_media_client.cc

 // Copyright 2016 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 "chromecast/media/service/cast_mojo_media_client.h"
 
 #include "base/memory/ptr_util.h"
 #include "chromecast/media/cma/backend/media_pipeline_backend_factory.h"
 #include "chromecast/media/service/cast_renderer.h"
 #include "chromecast/public/media/media_pipeline_backend.h"
@@ skipping 39 matching lines @@
  private:
   ~CastAudioRendererSink() final {}
 
   std::string device_id_;
   DISALLOW_COPY_AND_ASSIGN(CastAudioRendererSink);
 };
 
 class CastRendererFactory : public ::media::RendererFactory {
  public:
   CastRendererFactory(MediaPipelineBackendFactory* backend_factory,
-                      const scoped_refptr<::media::MediaLog>& media_log,
+                      ::media::MediaLog* media_log,

[chcunningham, 2017/04/18 23:29:12]

should we just kill the arg since we aren't using?

[DaleCurtis, 2017/04/18 23:55:45]

Done.

                       VideoModeSwitcher* video_mode_switcher,
                       VideoResolutionPolicy* video_resolution_policy,
                       MediaResourceTracker* media_resource_tracker)
       : backend_factory_(backend_factory),
-        media_log_(media_log),
         video_mode_switcher_(video_mode_switcher),
         video_resolution_policy_(video_resolution_policy),
         media_resource_tracker_(media_resource_tracker) {}
   ~CastRendererFactory() final {}
 
   std::unique_ptr<::media::Renderer> CreateRenderer(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       ::media::AudioRendererSink* audio_renderer_sink,
       ::media::VideoRendererSink* video_renderer_sink,
       const ::media::RequestSurfaceCB& request_surface_cb) final {
     DCHECK(audio_renderer_sink);
     DCHECK(!video_renderer_sink);
     return base::MakeUnique<CastRenderer>(
         backend_factory_, media_task_runner,
         audio_renderer_sink->GetOutputDeviceInfo().device_id(),
         video_mode_switcher_, video_resolution_policy_,
         media_resource_tracker_);
   }
 
  private:
   MediaPipelineBackendFactory* const backend_factory_;
-  scoped_refptr<::media::MediaLog> media_log_;
   VideoModeSwitcher* video_mode_switcher_;
   VideoResolutionPolicy* video_resolution_policy_;
   MediaResourceTracker* media_resource_tracker_;
   DISALLOW_COPY_AND_ASSIGN(CastRendererFactory);
 };
 }  // namespace
 
 CastMojoMediaClient::CastMojoMediaClient(
     MediaPipelineBackendFactory* backend_factory,
     const CreateCdmFactoryCB& create_cdm_factory_cb,
@@ skipping 17 matching lines @@
   connector_ = connector;
 }
 
 scoped_refptr<::media::AudioRendererSink>
 CastMojoMediaClient::CreateAudioRendererSink(
     const std::string& audio_device_id) {
   return new CastAudioRendererSink(audio_device_id);
 }
 
 std::unique_ptr<::media::RendererFactory>
-CastMojoMediaClient::CreateRendererFactory(
-    const scoped_refptr<::media::MediaLog>& media_log) {
+CastMojoMediaClient::CreateRendererFactory(::media::MediaLog* media_log) {
   return base::MakeUnique<CastRendererFactory>(
       backend_factory_, media_log, video_mode_switcher_,
       video_resolution_policy_, media_resource_tracker_);
 }
 
 std::unique_ptr<::media::CdmFactory> CastMojoMediaClient::CreateCdmFactory(
     service_manager::mojom::InterfaceProvider* /* host_interfaces */) {
   return create_cdm_factory_cb_.Run();
 }
 
 }  // namespace media
 }  // namespace chromecast