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