Preliminary change for new rtc rendering algorithm

content/renderer/media/webmediaplayer_ms.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 "content/renderer/media/webmediaplayer_ms.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 433 matching lines @@
   return true;
 }
 
 void WebMediaPlayerMS::SetVideoFrameProviderClient(
     cc::VideoFrameProvider::Client* client) {
   // This is called from both the main renderer thread and the compositor
   // thread (when the main thread is blocked).
   if (video_frame_provider_client_)
     video_frame_provider_client_->StopUsingProvider();
   video_frame_provider_client_ = client;
+  if (client)
+    client->StartRendering();

[DaleCurtis, 2015/08/04 21:49:26]

Where are you calling StopRendering? How are you handling backgrounding of the
tab?  If you turn this path on always, you won't get UpdateCurrentFrame calls
when the layer is invisible.

[qiangchen, 2015/08/04 22:13:24]

video_frame_provider_client_->StopUsingProvider() will call StopRendering(). 

For background rendering, I found VideoFrameCompositor uses a
background_rendering_timer_ to do background rendering when UpdateCurrentFrame
does not get called for a period of time. In WebMediaPlayerMS, I think there is
a simpler solution: just record the last deadline_max passed in
UpdateCurrentFrame, when a new frame comes to OnFrameAvailable (which never
stops even when the tab is invisible), if Now>last recorded deadline_max, then
we call VRA::RemoveExpiredFrames to let old frames go. 

[DaleCurtis, 2015/08/04 23:19:14]

Well, delivering begin frame callbacks is expensive in terms of power, if you
have no frames, you shouldn't be setting this flag.

It sounds like you're saying you'll accumulate massive amounts of frames within
the VRA, that would take a lot of memory usage, no? Also what are you going to
do about WebGL copies? I don't think any solution that doesn't result in you
using VideoFrameCompositor is going to work very well.

[qiangchen, 2015/08/04 23:45:45]

I did not quite understand what is " delivering begin frame callbacks". What I
found is that when the tab is invisible, UpdateCurrentFrame will not be called.
Did you mean that at this time if we do not call client->StopRendering(), there
is a performance impact?
Never, when UpdateCurrentFrame is not called, we are going to call
RemoveExpiredFrames in OnFrameAvailable to let frames go.

[DaleCurtis, 2015/08/04 23:49:02]

You shouldn't keep rendering enabled when the tab is visible and you have
nothing to render as it wastes power.  If you know you have nothing new to
render (i.e., the video is paused in <video> case) you should call
StopRendering() to avoid wasting power.
It sounds like you're going to implement your timeout callback... for which
you'd need to add workarounds for WebGL... for which is exactly what
VideoFrameCompositor will handle for you :)

[qiangchen, 2015/08/05 16:23:57]

Let me do another patch to explain this issue.

 }
 
 bool WebMediaPlayerMS::UpdateCurrentFrame(base::TimeTicks deadline_min,
                                           base::TimeTicks deadline_max) {
+  TRACE_EVENT_BEGIN2("webrtc", "WebMediaPlayerMS::UpdateCurrentFrame",
+                     "Actual Render Begin", deadline_min.ToInternalValue(),
+                     "Actual Render End", deadline_max.ToInternalValue());
+
   // TODO(dalecurtis): This should make use of the deadline interval to ensure
   // the painted frame is correct for the given interval.
-  NOTREACHED();
-  return false;
+
+  base::TimeTicks render_time;
+  if (!current_frame_->metadata()->GetTimeTicks(
+          media::VideoFrameMetadata::REFERENCE_TIME, &render_time)) {
+    render_time = base::TimeTicks();
+  }
+  TRACE_EVENT_END1("webrtc", "WebMediaPlayerMS::UpdateCurrentFrame",
+                   "Ideal Render Instant", render_time.ToInternalValue());
+  return !current_frame_used_;
 }
 
 bool WebMediaPlayerMS::HasCurrentFrame() {
   base::AutoLock auto_lock(current_frame_lock_);
   return current_frame_;
 }
 
 scoped_refptr<media::VideoFrame> WebMediaPlayerMS::GetCurrentFrame() {
   DVLOG(3) << "WebMediaPlayerMS::GetCurrentFrame";
   base::AutoLock auto_lock(current_frame_lock_);
   if (!current_frame_.get())
     return NULL;
   current_frame_used_ = true;
   return current_frame_;
 }
 
 void WebMediaPlayerMS::PutCurrentFrame() {
   DVLOG(3) << "WebMediaPlayerMS::PutCurrentFrame";
 }
 
 void WebMediaPlayerMS::OnFrameAvailable(
     const scoped_refptr<media::VideoFrame>& frame) {
   DVLOG(3) << "WebMediaPlayerMS::OnFrameAvailable";
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  base::TimeTicks render_time;
+  if (!frame->metadata()->GetTimeTicks(
+          media::VideoFrameMetadata::REFERENCE_TIME, &render_time)) {
+    render_time = base::TimeTicks();
+  }
+  TRACE_EVENT1("webrtc", "WebMediaPlayerMS::OnFrameAvailable",
+               "Ideal Render Instant", render_time.ToInternalValue());
+
   ++total_frame_count_;
   if (!received_first_frame_) {
     received_first_frame_ = true;
     {
       base::AutoLock auto_lock(current_frame_lock_);
       DCHECK(!current_frame_used_);
       current_frame_ = frame;
     }
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
@@ skipping 19 matching lines @@
     base::AutoLock auto_lock(current_frame_lock_);
     if (!current_frame_used_ && current_frame_.get())
       ++dropped_frame_count_;
     current_frame_ = frame;
     current_time_ = frame->timestamp();
     current_frame_used_ = false;
   }
 
   if (size_changed)
     GetClient()->sizeChanged();
-
-  GetClient()->repaint();
 }
 
 void WebMediaPlayerMS::RepaintInternal() {
   DVLOG(1) << "WebMediaPlayerMS::RepaintInternal";
   DCHECK(thread_checker_.CalledOnValidThread());
   GetClient()->repaint();
 }
 
 void WebMediaPlayerMS::OnSourceError() {
   DVLOG(1) << "WebMediaPlayerMS::OnSourceError";
@@ skipping 16 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 blink::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace content