Remove WebVideoFrame, WebVideoFrameProvider, and WebVideoLayer.

webkit/media/webmediaplayer_impl.cc

 // Copyright (c) 2012 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 "webkit/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
+#include "cc/layers/video_layer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/filter_collection.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 #include "media/filters/audio_renderer_impl.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/video_renderer_base.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRuntimeFeatures.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "v8/include/v8.h"
+#include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/media/buffered_data_source.h"
 #include "webkit/media/filter_helpers.h"
 #include "webkit/media/webaudiosourceprovider_impl.h"
 #include "webkit/media/webmediaplayer_delegate.h"
 #include "webkit/media/webmediaplayer_params.h"
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webmediasourceclient_impl.h"
-#include "webkit/media/webvideoframe_impl.h"
 #include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebMediaPlayer;
 using WebKit::WebRect;
 using WebKit::WebSize;
 using WebKit::WebString;
 using media::PipelineStatus;
 
 namespace {
@@ skipping 83 matching lines @@
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       client_(client),
       delegate_(delegate),
       media_log_(params.media_log()),
       accelerated_compositing_reported_(false),
       incremented_externally_allocated_memory_(false),
       is_local_source_(false),
       supports_save_(true),
       starting_(false),
-      pending_repaint_(false) {
+      pending_repaint_(false),
+      video_frame_provider_client_(NULL) {
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   CHECK(media_thread_.Start());
   pipeline_ = new media::Pipeline(
       media_thread_.message_loop_proxy(), media_log_);
 
   // Let V8 know we started new thread if we did not do it yet.
   // Made separate task to avoid deletion of player currently being created.
   // Also, delaying GC until after player starts gets rid of starting lag --
@@ skipping 45 matching lines @@
       new media::NullAudioSink(media_thread_.message_loop_proxy()));
   scoped_ptr<media::AudioRenderer> audio_renderer(
       new media::AudioRendererImpl(
         media_thread_.message_loop_proxy(),
         audio_source_provider_,
         set_decryptor_ready_cb));
   filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
+  SetVideoFrameProviderClient(NULL);
+  // No need for a lock here, as GetCurrentFrame/PutCurrentFrame can't be
+  // called now that the client is no longer using this provider. Also, load()
+  // and this destructor are called from the same thread.
+  setStreamTextureClient(NULL);

[scherkus (not reviewing), 2013/03/18 21:38:24]

isn't this handled by the call to SVFPC(NULL)?

[danakj, 2013/03/18 21:57:59]

Oh, yes! This is the one sketchy thing about this change I feel.

Before, when detroying the WebMediaPlayerClientImpl, it would call
stopUsingProvider on the VFPClient. But would not not set the vfpClient to NULL.
Then it would setStreamTextureClient(NULL).

In between, the compositor thread could be calling didReceiveFrame() which would
call the vfpClient and work fine. Now, we set the vfpClient pointer to NULL and
it would crash.

To fix this I think we should either:
1) Lock inside didReceiveFrame on the provider_lock_ and only call
vfpClient->DidReceiveFrame() if its not null.

or

2) Not set the vfpClient to NULL when shutting down, and explicitly just
vfpClient->StopUsingProvider() and setStreamTextureClient(NULL) here.

[scherkus (not reviewing), 2013/03/18 23:34:18]

I'm a bit confused. An IM/VC convo might be in order :)

Are you saying ~WMPI() can be in the middle of execution (e.g., after setting
video_frame_provider_client_ to NULL) while WMPI::didReceiveFrame() is being
called?

If it's helpful, I believe dRF() is only used in the stream texture case, which
is only present on Android. I believe (hope?) WebMediaPlayerAndroid can
guarantee that it tears down the stream texture machinery so that we're not
racing inside a destructor
https://code.google.com/p/chromium/codesearch#chromium/src/webkit/media/andro...

(note: I just remembered you'll have to fix up the Android WebMediaPlayers as
well)

[danakj, 2013/03/18 23:37:15]

Without looking at the android code, it would be possible from the WMPI api
alone. But I guess I should look at the android code then.
Oh! Does this mean only the android version should even set up the
streamTextureClient?

+
   DCHECK(main_loop_->BelongsToCurrentThread());
   Destroy();
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_)
     delegate_->PlayerGone(this);
 
   // Remove destruction observer if we're being destroyed but the main thread is
   // still running.
@@ skipping 425 matching lines @@
   return stats.audio_bytes_decoded;
 }
 
 unsigned WebMediaPlayerImpl::videoDecodedByteCount() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.video_bytes_decoded;
 }
 
-WebKit::WebVideoFrame* WebMediaPlayerImpl::getCurrentFrame() {
-  base::AutoLock auto_lock(lock_);
-  if (current_frame_)
-    return new WebVideoFrameImpl(current_frame_);
-  return NULL;
+WebKit::WebLayer* WebMediaPlayerImpl::createCompositingLayer() {
+  return new webkit::WebLayerImpl(cc::VideoLayer::Create(this));
 }
 
-void WebMediaPlayerImpl::putCurrentFrame(
-    WebKit::WebVideoFrame* web_video_frame) {
+void WebMediaPlayerImpl::SetVideoFrameProviderClient(
+    cc::VideoFrameProvider::Client* client) {
+  base::AutoLock auto_lock(provider_lock_);
+  if (video_frame_provider_client_)
+    video_frame_provider_client_->StopUsingProvider();
+  video_frame_provider_client_ = client;
+  setStreamTextureClient(client ? this : NULL);
+}
+
+scoped_refptr<media::VideoFrame> WebMediaPlayerImpl::GetCurrentFrame() {
+  base::AutoLock auto_lock(lock_);
+  return current_frame_;
+}
+
+void WebMediaPlayerImpl::PutCurrentFrame(
+    const scoped_refptr<media::VideoFrame>& frame) {
+  base::AutoLock auto_lock(lock_);
   if (!accelerated_compositing_reported_) {
     accelerated_compositing_reported_ = true;
     DCHECK(frame_->view()->isAcceleratedCompositingActive());
     UMA_HISTOGRAM_BOOLEAN("Media.AcceleratedCompositingActive", true);
   }
-  delete web_video_frame;
+}
+
+void WebMediaPlayerImpl::didReceiveFrame() {
+  // No lock since this gets called on the client's thread.
+  video_frame_provider_client_->DidReceiveFrame();
+}
+
+void WebMediaPlayerImpl::didUpdateMatrix(const float* matrix) {
+  // No lock since this gets called on the client's thread.
+  video_frame_provider_client_->DidUpdateMatrix(matrix);
 }
 
 bool WebMediaPlayerImpl::copyVideoTextureToPlatformTexture(
     WebKit::WebGraphicsContext3D* web_graphics_context,
     unsigned int texture,
     unsigned int level,
     unsigned int internal_format,
     bool premultiply_alpha,
     bool flip_y) {
   scoped_refptr<media::VideoFrame> video_frame;
@@ skipping 516 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media