Eliminate MediaPlayer & MediaPlayerClient abstractions

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 88 matching lines @@
   (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   BindToCurrentLoop(base::Bind(function, AsWeakPtr())))
 
 #define BIND_TO_RENDER_LOOP1(function, arg1) \
   (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   BindToCurrentLoop(base::Bind(function, AsWeakPtr(), arg1)))
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     blink::WebLocalFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,

[ddorwin, 2015/05/26 21:43:07]

We've never had to duplicate this constructor before. You shouldn't need to do
this.

[Srirama, 2015/05/27 14:48:50]

I need to setup the path for encrypted_client related functions before i can
remove them from WebMediaPlayerClient on blink side. We need both clients
because finally we need to invoke encrypted related functions alone with
"encrypted_client_" and keep other things as it is with "client_".

     scoped_ptr<RendererFactory> renderer_factory,
     CdmFactory* cdm_factory,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       preload_(BufferedDataSource::AUTO),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       media_task_runner_(params.media_task_runner()),
       media_log_(params.media_log()),
@@ skipping 17 matching lines @@
       compositor_task_runner_(
           params.compositor_task_runner()
               ? params.compositor_task_runner()
               : base::MessageLoop::current()->task_runner()),
       compositor_(new VideoFrameCompositor(
           compositor_task_runner_,
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnOpacityChanged))),
       encrypted_media_support_(cdm_factory,
                                client,
+                               nullptr,
                                params.media_permission(),
                                base::Bind(&WebMediaPlayerImpl::SetCdm,
                                           AsWeakPtr(),
+                                          base::Bind(&IgnoreCdmAttached))),
+      renderer_factory_(renderer_factory.Pass()) {
+  media_log_->AddEvent(
+      media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
+
+  if (params.initial_cdm()) {
+    SetCdm(base::Bind(&IgnoreCdmAttached),
+           ToWebContentDecryptionModuleImpl(params.initial_cdm())
+               ->GetCdmContext());
+  }
+
+  // TODO(xhwang): When we use an external Renderer, many methods won't work,
+  // e.g. GetCurrentFrameFromCompositor(). See http://crbug.com/434861
+
+  // Use the null sink if no sink was provided.
+  audio_source_provider_ = new WebAudioSourceProviderImpl(
+      params.audio_renderer_sink().get()
+          ? params.audio_renderer_sink()
+          : new NullAudioSink(media_task_runner_));
+}
+
+WebMediaPlayerImpl::WebMediaPlayerImpl(
+    blink::WebLocalFrame* frame,
+    blink::WebMediaPlayerClient* client,
+    blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
+    base::WeakPtr<WebMediaPlayerDelegate> delegate,
+    scoped_ptr<RendererFactory> renderer_factory,
+    CdmFactory* cdm_factory,
+    const WebMediaPlayerParams& params)
+    : frame_(frame),
+      network_state_(WebMediaPlayer::NetworkStateEmpty),
+      ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
+      preload_(BufferedDataSource::AUTO),
+      main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      media_task_runner_(params.media_task_runner()),
+      media_log_(params.media_log()),
+      pipeline_(media_task_runner_, media_log_.get()),
+      load_type_(LoadTypeURL),
+      opaque_(false),
+      paused_(true),
+      seeking_(false),
+      playback_rate_(0.0),
+      ended_(false),
+      pending_seek_(false),
+      pending_seek_seconds_(0.0f),
+      should_notify_time_changed_(false),
+      client_(client),
+      encrypted_client_(encrypted_client),
+      delegate_(delegate),
+      defer_load_cb_(params.defer_load_cb()),
+      context_3d_cb_(params.context_3d_cb()),
+      supports_save_(true),
+      chunk_demuxer_(NULL),
+      // Threaded compositing isn't enabled universally yet.
+      compositor_task_runner_(
+          params.compositor_task_runner()
+              ? params.compositor_task_runner()
+              : base::MessageLoop::current()->task_runner()),
+      compositor_(new VideoFrameCompositor(
+          compositor_task_runner_,
+          BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
+          BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnOpacityChanged))),
+      encrypted_media_support_(cdm_factory,
+                               client,
+                               encrypted_client,
+                               params.media_permission(),
+                               base::Bind(&WebMediaPlayerImpl::SetCdm,
+                                          AsWeakPtr(),
                                           base::Bind(&IgnoreCdmAttached))),
       renderer_factory_(renderer_factory.Pass()) {
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   if (params.initial_cdm()) {
     SetCdm(base::Bind(&IgnoreCdmAttached),
            ToWebContentDecryptionModuleImpl(params.initial_cdm())
                ->GetCdmContext());
   }
@@ skipping 519 matching lines @@
   }
 
   // TODO(xhwang): Update this UMA name.
   UMA_HISTOGRAM_COUNTS("Media.EME.NeedKey", 1);
 
   encrypted_media_support_.SetInitDataType(init_data_type);
 
   client_->encrypted(ConvertToWebInitDataType(init_data_type),
                      vector_as_array(&init_data),
                      base::saturated_cast<unsigned int>(init_data.size()));
+  if (encrypted_client_)
+    encrypted_client_->encrypted(
+        ConvertToWebInitDataType(init_data_type), vector_as_array(&init_data),
+        base::saturated_cast<unsigned int>(init_data.size()));
 }
 
 void WebMediaPlayerImpl::OnWaitingForDecryptionKey() {
   client_->didBlockPlaybackWaitingForKey();
+  if (encrypted_client_)
+    encrypted_client_->didBlockPlaybackWaitingForKey();
 
   // TODO(jrummell): didResumePlaybackBlockedForKey() should only be called
   // when a key has been successfully added (e.g. OnSessionKeysChange() with
   // |has_additional_usable_key| = true). http://crbug.com/461903
   client_->didResumePlaybackBlockedForKey();
+  if (encrypted_client_)
+    encrypted_client_->didResumePlaybackBlockedForKey();
 }
 
 void WebMediaPlayerImpl::SetCdm(const CdmAttachedCB& cdm_attached_cb,
                                 CdmContext* cdm_context) {
   // If CDM initialization succeeded, tell the pipeline about it.
   if (cdm_context)
     pipeline_.SetCdm(cdm_context, cdm_attached_cb);
 }
 
 void WebMediaPlayerImpl::OnCdmAttached(
@@ skipping 307 matching lines @@
 
   // pause() may be called after playback has ended and the HTMLMediaElement
   // requires that currentTime() == duration() after ending.  We want to ensure
   // |paused_time_| matches currentTime() in this case or a future seek() may
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 }
 
 }  // namespace media