Convert MediaLog from being ref counted to owned by WebMediaPlayer.

media/blink/webmediaplayer_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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 159 matching lines @@
 STATIC_ASSERT_ENUM(WebMediaPlayer::kCORSModeUseCredentials,
                    UrlData::CORS_USE_CREDENTIALS);
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     blink::WebLocalFrame* frame,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     WebMediaPlayerDelegate* delegate,
     std::unique_ptr<RendererFactory> renderer_factory,
     linked_ptr<UrlIndex> url_index,
-    const WebMediaPlayerParams& params)
+    std::unique_ptr<WebMediaPlayerParams> params)
     : frame_(frame),
       delegate_state_(DelegateState::GONE),
       delegate_has_audio_(false),
       network_state_(WebMediaPlayer::kNetworkStateEmpty),
       ready_state_(WebMediaPlayer::kReadyStateHaveNothing),
       highest_ready_state_(WebMediaPlayer::kReadyStateHaveNothing),
       preload_(MultibufferDataSource::AUTO),
       main_task_runner_(frame->LoadingTaskRunner()),
-      media_task_runner_(params.media_task_runner()),
-      worker_task_runner_(params.worker_task_runner()),
-      media_log_(params.media_log()),
+      media_task_runner_(params->media_task_runner()),
+      worker_task_runner_(params->worker_task_runner()),
+      media_log_(params->media_log()),
       pipeline_controller_(
           base::MakeUnique<PipelineImpl>(media_task_runner_, media_log_.get()),
           base::Bind(&WebMediaPlayerImpl::CreateRenderer,
                      base::Unretained(this)),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSeeked, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnPipelineSuspended, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnBeforePipelineResume, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnPipelineResumed, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnError, AsWeakPtr())),
       load_type_(kLoadTypeURL),
       opaque_(false),
       playback_rate_(0.0),
       paused_(true),
       paused_when_hidden_(false),
       seeking_(false),
       pending_suspend_resume_cycle_(false),
       ended_(false),
       should_notify_time_changed_(false),
       overlay_enabled_(false),
       decoder_requires_restart_for_overlay_(false),
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
       delegate_id_(0),
-      defer_load_cb_(params.defer_load_cb()),
-      context_3d_cb_(params.context_3d_cb()),
-      adjust_allocated_memory_cb_(params.adjust_allocated_memory_cb()),
+      defer_load_cb_(params->defer_load_cb()),
+      context_3d_cb_(params->context_3d_cb()),
+      adjust_allocated_memory_cb_(params->adjust_allocated_memory_cb()),
       last_reported_memory_usage_(0),
       supports_save_(true),
       chunk_demuxer_(NULL),
       url_index_(url_index),
       // Threaded compositing isn't enabled universally yet.
-      compositor_task_runner_(params.compositor_task_runner()
-                                  ? params.compositor_task_runner()
+      compositor_task_runner_(params->compositor_task_runner()
+                                  ? params->compositor_task_runner()
                                   : base::ThreadTaskRunnerHandle::Get()),
       compositor_(new VideoFrameCompositor(compositor_task_runner_)),
 #if defined(OS_ANDROID)  // WMPI_CAST
-      cast_impl_(this, client_, params.context_3d_cb()),
+      cast_impl_(this, client_, params->context_3d_cb()),
 #endif
       volume_(1.0),
       volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)),
-      surface_manager_(params.surface_manager()),
+      surface_manager_(params->surface_manager()),
       overlay_surface_id_(SurfaceManager::kNoSurfaceID),
       suppress_destruction_errors_(false),
-      suspend_enabled_(params.allow_suspend()),
+      suspend_enabled_(params->allow_suspend()),
       use_fallback_path_(false),
       is_encrypted_(false),
       preroll_attempt_pending_(false),
-      observer_(params.media_observer()),
+      observer_(params->media_observer()),
       max_keyframe_distance_to_disable_background_video_(
-          params.max_keyframe_distance_to_disable_background_video()),
+          params->max_keyframe_distance_to_disable_background_video()),
       max_keyframe_distance_to_disable_background_video_mse_(
-          params.max_keyframe_distance_to_disable_background_video_mse()),
+          params->max_keyframe_distance_to_disable_background_video_mse()),
       enable_instant_source_buffer_gc_(
-          params.enable_instant_source_buffer_gc()),
+          params->enable_instant_source_buffer_gc()),
       embedded_media_experience_enabled_(
-          params.embedded_media_experience_enabled()) {
+          params->embedded_media_experience_enabled()) {
   DVLOG(1) << __func__;
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
   DCHECK(delegate_);
 
   tick_clock_.reset(new base::DefaultTickClock());
 
   force_video_overlays_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kForceVideoOverlays);
 
   enable_fullscreen_video_overlays_ =
       base::FeatureList::IsEnabled(media::kOverlayFullscreenVideo);
 
   delegate_id_ = delegate_->AddObserver(this);
   delegate_->SetIdle(delegate_id_, true);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
-  if (params.initial_cdm())
-    SetCdm(params.initial_cdm());
+  if (params->initial_cdm())
+    SetCdm(params->initial_cdm());
 
   // TODO(xhwang): When we use an external Renderer, many methods won't work,
   // e.g. GetCurrentFrameFromCompositor(). See http://crbug.com/434861
-  audio_source_provider_ =
-      new WebAudioSourceProviderImpl(params.audio_renderer_sink(), media_log_);
+  audio_source_provider_ = new WebAudioSourceProviderImpl(
+      params->audio_renderer_sink(), media_log_.get());
 
   if (observer_)
     observer_->SetClient(this);
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (set_cdm_result_) {
@@ skipping 106 matching lines @@
   delegate_->SetIsEffectivelyFullscreen(delegate_id_, isEffectivelyFullscreen);
 }
 
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
                                 const blink::WebURL& url,
                                 CORSMode cors_mode) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   GURL gurl(url);
-  ReportMetrics(load_type, gurl, frame_->GetSecurityOrigin(), media_log_);
+  ReportMetrics(load_type, gurl, frame_->GetSecurityOrigin(), media_log_.get());
 
   // Set subresource URL for crash reporting.
   base::debug::SetCrashKeyValue("subresource_url", gurl.spec());
 
   if (use_fallback_path_)
     fallback_url_ = gurl;
 
   load_type_ = load_type;
 
   SetNetworkState(WebMediaPlayer::kNetworkStateLoading);
@@ skipping 248 matching lines @@
     const blink::WebVector<blink::WebMediaPlayer::TrackId>& enabledTrackIds) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   std::ostringstream logstr;
   std::vector<MediaTrack::Id> enabledMediaTrackIds;
   for (const auto& blinkTrackId : enabledTrackIds) {
     MediaTrack::Id track_id = blinkTrackId.Utf8().data();
     logstr << track_id << " ";
     enabledMediaTrackIds.push_back(track_id);
   }
-  MEDIA_LOG(INFO, media_log_) << "Enabled audio tracks: [" << logstr.str()
-                              << "]";
+  MEDIA_LOG(INFO, media_log_.get())
+      << "Enabled audio tracks: [" << logstr.str() << "]";
   pipeline_controller_.OnEnabledAudioTracksChanged(enabledMediaTrackIds);
 }
 
 void WebMediaPlayerImpl::SelectedVideoTrackChanged(
     blink::WebMediaPlayer::TrackId* selectedTrackId) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   base::Optional<MediaTrack::Id> selected_video_track_id;
   if (selectedTrackId && !video_track_disabled_)
     selected_video_track_id = MediaTrack::Id(selectedTrackId->Utf8().data());
-  MEDIA_LOG(INFO, media_log_) << "Selected video track: ["
-                              << selected_video_track_id.value_or("") << "]";
+  MEDIA_LOG(INFO, media_log_.get())
+      << "Selected video track: [" << selected_video_track_id.value_or("")
+      << "]";
   pipeline_controller_.OnSelectedVideoTrackChanged(selected_video_track_id);
 }
 
 bool WebMediaPlayerImpl::GetLastUploadedFrameInfo(unsigned* width,
                                                   unsigned* height,
                                                   double* timestamp) {
   *width = last_uploaded_frame_size_.width();
   *height = last_uploaded_frame_size_.height();
   *timestamp = last_uploaded_frame_timestamp_.InSecondsF();
   return true;
@@ skipping 483 matching lines @@
 }
 
 void WebMediaPlayerImpl::OnPipelineResumed() {
   is_pipeline_resuming_ = false;
 
   UpdateBackgroundVideoOptimizationState();
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  client_->MediaSourceOpened(
-      new WebMediaSourceImpl(chunk_demuxer_, media_log_));
+  client_->MediaSourceOpened(new WebMediaSourceImpl(chunk_demuxer_));
 }
 
 void WebMediaPlayerImpl::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   DVLOG(2) << __func__ << " memory_pressure_level=" << memory_pressure_level;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(base::FeatureList::IsEnabled(kMemoryPressureBasedSourceBufferGC));
   DCHECK(chunk_demuxer_);
 
   // The new value of |memory_pressure_level| will take effect on the next
@@ skipping 20 matching lines @@
 }
 
 void WebMediaPlayerImpl::OnError(PipelineStatus status) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(status, PIPELINE_OK);
 
   if (suppress_destruction_errors_)
     return;
 
-  ReportPipelineError(load_type_, status, media_log_);
+  ReportPipelineError(load_type_, status, media_log_.get());
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(status));
 
   if (ready_state_ == WebMediaPlayer::kReadyStateHaveNothing) {
     // Any error that occurs before reaching ReadyStateHaveMetadata should
     // be considered a format error.
     SetNetworkState(WebMediaPlayer::kNetworkStateFormatError);
   } else {
     SetNetworkState(PipelineErrorToNetworkState(status));
   }
 
@@ skipping 510 matching lines @@
   // Figure out which demuxer to use.
   if (load_type_ != kLoadTypeMediaSource) {
     DCHECK(!chunk_demuxer_);
     DCHECK(data_source_);
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
     Demuxer::MediaTracksUpdatedCB media_tracks_updated_cb =
         BindToCurrentLoop(base::Bind(
             &WebMediaPlayerImpl::OnFFmpegMediaTracksUpdated, AsWeakPtr()));
 
-    demuxer_.reset(new FFmpegDemuxer(media_task_runner_, data_source_.get(),
-                                     encrypted_media_init_data_cb,
-                                     media_tracks_updated_cb, media_log_));
+    demuxer_.reset(new FFmpegDemuxer(
+        media_task_runner_, data_source_.get(), encrypted_media_init_data_cb,
+        media_tracks_updated_cb, media_log_.get()));
 #else
     OnError(PipelineStatus::DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
 #endif
   } else {
     DCHECK(!chunk_demuxer_);
     DCHECK(!data_source_);
 
     chunk_demuxer_ = new ChunkDemuxer(
         BindToCurrentLoop(
             base::Bind(&WebMediaPlayerImpl::OnDemuxerOpened, AsWeakPtr())),
-        encrypted_media_init_data_cb, media_log_);
+        encrypted_media_init_data_cb, media_log_.get());
     demuxer_.reset(chunk_demuxer_);
 
     if (base::FeatureList::IsEnabled(kMemoryPressureBasedSourceBufferGC)) {
       // base::Unretained is safe because |this| owns memory_pressure_listener_.
       memory_pressure_listener_ =
           base::MakeUnique<base::MemoryPressureListener>(base::Bind(
               &WebMediaPlayerImpl::OnMemoryPressure, base::Unretained(this)));
     }
   }
 
@@ skipping 366 matching lines @@
   // Idle timeout chosen arbitrarily.
   background_pause_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(5),
                                 this, &WebMediaPlayerImpl::OnPause);
 }
 
 void WebMediaPlayerImpl::CreateWatchTimeReporter() {
   // Create the watch time reporter and synchronize its initial state.
   watch_time_reporter_.reset(
       new WatchTimeReporter(HasAudio(), HasVideo(), !!chunk_demuxer_,
                             is_encrypted_, embedded_media_experience_enabled_,
-                            media_log_, pipeline_metadata_.natural_size,
+                            media_log_.get(), pipeline_metadata_.natural_size,
                             base::Bind(&GetCurrentTimeInternal, this)));
   watch_time_reporter_->OnVolumeChange(volume_);
   if (delegate_->IsFrameHidden())
     watch_time_reporter_->OnHidden();
   else
     watch_time_reporter_->OnShown();
 }
 
 bool WebMediaPlayerImpl::IsHidden() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ skipping 185 matching lines @@
 
 void WebMediaPlayerImpl::RecordUnderflowDuration(base::TimeDelta duration) {
   DCHECK(data_source_ || chunk_demuxer_);
   if (data_source_)
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration", duration);
   else
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration.MSE", duration);
 }
 
 }  // namespace media