Replace VideoRendererBase Get/PutCurrentFrame() with a VideoFrame-containing callback.

webkit/media/webmediaplayer_proxy.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_proxy.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "media/base/pipeline_status.h"
@@ skipping 16 matching lines @@
       webmediaplayer_(webmediaplayer),
       outstanding_repaints_(0) {
   DCHECK(render_loop_);
   DCHECK(webmediaplayer_);
 }
 
 WebMediaPlayerProxy::~WebMediaPlayerProxy() {
   Detach();
 }
 
-void WebMediaPlayerProxy::Repaint() {
+void WebMediaPlayerProxy::FrameReady(
+    const scoped_refptr<media::VideoFrame>& frame) {
   base::AutoLock auto_lock(lock_);
+  current_frame_ = frame;

[acolwell GONE FROM CHROMIUM, 2013/02/01 00:24:34]

I think you need more code in here to track dropped frames. It seems to me that
there should be some coordination between this function and GetCurrentFrame().
You need to be able to detect how many times current_frame_ gets updated before
another paint actually happens. This would be the number of frames that were
dropped.

[scherkus (not reviewing), 2013/02/01 22:45:25]

As discussed offline, I added back the frame dropping code that was accidentally
removed. The metric is purely based on missed deadlines due to stalls in the
pipeline.

+
   if (outstanding_repaints_ < kMaxOutstandingRepaints) {
     ++outstanding_repaints_;
 
     render_loop_->PostTask(FROM_HERE, base::Bind(
         &WebMediaPlayerProxy::RepaintTask, this));
   }
 }
 
 void WebMediaPlayerProxy::Paint(SkCanvas* canvas,
                                 const gfx::Rect& dest_rect,
                                 uint8_t alpha) {
   DCHECK(render_loop_->BelongsToCurrentThread());
-  if (frame_provider_) {
-    scoped_refptr<media::VideoFrame> video_frame;
-    frame_provider_->GetCurrentFrame(&video_frame);
-    video_renderer_.Paint(video_frame, canvas, dest_rect, alpha);
-    frame_provider_->PutCurrentFrame(video_frame);
-  }
+
+  // Use GetCurrentFrame() to avoid locking while painting in software.
+  scoped_refptr<media::VideoFrame> video_frame;
+  GetCurrentFrame(&video_frame);
+  video_renderer_.Paint(video_frame, canvas, dest_rect, alpha);
 }
 
 bool WebMediaPlayerProxy::HasSingleOrigin() {
   DCHECK(render_loop_->BelongsToCurrentThread());
   if (data_source_)
     return data_source_->HasSingleOrigin();
   return true;
 }
 
 bool WebMediaPlayerProxy::DidPassCORSAccessCheck() const {
@@ skipping 23 matching lines @@
     --outstanding_repaints_;
     DCHECK_GE(outstanding_repaints_, 0);
   }
   if (webmediaplayer_) {
     webmediaplayer_->Repaint();
   }
 }
 
 void WebMediaPlayerProxy::GetCurrentFrame(
     scoped_refptr<media::VideoFrame>* frame_out) {
-  if (frame_provider_)
-    frame_provider_->GetCurrentFrame(frame_out);
-}
-
-void WebMediaPlayerProxy::PutCurrentFrame(
-    scoped_refptr<media::VideoFrame> frame) {
-  if (frame_provider_)
-    frame_provider_->PutCurrentFrame(frame);
+  base::AutoLock auto_lock(lock_);
+  *frame_out = current_frame_;
 }
 
 }  // namespace webkit_media