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();
+  }

[mcasas, 2015/07/30 08:40:24]

no need for {}

[qiangchen, 2015/07/30 17:40:26]

Done.

 }
 
 bool WebMediaPlayerMS::UpdateCurrentFrame(base::TimeTicks deadline_min,
                                           base::TimeTicks deadline_max) {

[mcasas, 2015/07/30 08:40:24]

Suggestion: change base::TimeTicks to base::TimeDelta and 
things will make more sense?

[DaleCurtis, 2015/07/30 16:26:04]

These are values forwarded from the compositor BeginFrameArgs structure and are
relative to the values returned by base::TimeTicks::Now(), so they should be
TimeTicks. Can you elaborate on your idea here?

[qiangchen, 2015/07/30 17:40:26]

Did you mean deadline_min and deadline_max? 
UpdateCurrentFrame is an overriden function from base class. If we change that,
we need to change every implementation and every call.

[mcasas, 2015/07/31 08:41:31]

Yes, it would mean changing base class and derived
classes. Perhaps even Blink, so might be too large a
change for this CL (in this case, please add a 
// TODO() and create a crbug.com).

My understanding was that base::TimeTicks is better
avoided (http://crbug.com/467417), miu@ can comment
on it some more, due to clock skews, and it can
be transformed, nontrivially, into TimeDeltas from
UTC.

[DaleCurtis, 2015/07/31 16:05:07]

TimeTicks is the correct usage here since these values are the system clock
times at which a frame would be displayed.  They are used in conjunction with
base::TimeTicks::Now() for scheduling.

+  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 = current_frame_->render_time();

[mcasas, 2015/07/30 08:40:24]

const

[qiangchen, 2015/07/30 17:40:26]

Done.

[qiangchen, 2015/07/31 17:15:33]

N/A

+  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());
+
+  TRACE_EVENT1("webrtc", "WebMediaPlayerMS::OnFrameAvailable",
+               "Ideal Render Instant", frame->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