Prototype HTMLVideoElement properties for WebGL texImage2D

media/blink/webmediaplayer_impl.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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 685 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   base::Optional<MediaTrack::Id> selected_video_track_id;
   if (selectedTrackId && !video_track_disabled_)
     selected_video_track_id = MediaTrack::Id(selectedTrackId->utf8().data());
   MEDIA_LOG(INFO, media_log_) << "Selected video track: ["
                               << selected_video_track_id.value_or("") << "]";
   pipeline_controller_.OnSelectedVideoTrackChanged(selected_video_track_id);
 }
 
+bool WebMediaPlayerImpl::getLastUploadedFrameInfo(unsigned* width,
+                                                  unsigned* height,
+                                                  double* timestamp) {
+  *width = last_uploaded_frame_size_.width();
+  *height = last_uploaded_frame_size_.height();
+  *timestamp = last_uploaded_frame_timestamp_.InSecondsF();
+  return true;
+}
+
 blink::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return blink::WebSize(pipeline_metadata_.natural_size);
 }
 
 bool WebMediaPlayerImpl::paused() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
 #if defined(OS_ANDROID)  // WMPI_CAST
@@ skipping 1110 matching lines @@
   *video_frame_out = compositor->GetCurrentFrameAndUpdateIfStale();
   event->Signal();
 }
 
 scoped_refptr<VideoFrame> WebMediaPlayerImpl::GetCurrentFrameFromCompositor() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("media", "WebMediaPlayerImpl::GetCurrentFrameFromCompositor");
 
   // Needed when the |main_task_runner_| and |compositor_task_runner_| are the
   // same to avoid deadlock in the Wait() below.
-  if (compositor_task_runner_->BelongsToCurrentThread())
-    return compositor_->GetCurrentFrameAndUpdateIfStale();
+  if (compositor_task_runner_->BelongsToCurrentThread()) {
+    scoped_refptr<VideoFrame> video_frame =
+        compositor_->GetCurrentFrameAndUpdateIfStale();
+    if (!video_frame) {
+      return nullptr;
+    }
+    last_uploaded_frame_size_ = video_frame->natural_size();
+    last_uploaded_frame_timestamp_ = video_frame->timestamp();
+    return video_frame;
+  }
 
   // Use a posted task and waitable event instead of a lock otherwise
   // WebGL/Canvas can see different content than what the compositor is seeing.
   scoped_refptr<VideoFrame> video_frame;
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
   compositor_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GetCurrentFrameAndSignal, base::Unretained(compositor_),
                  &video_frame, &event));
   event.Wait();
+
+  if (!video_frame) {
+    return nullptr;
+  }
+  last_uploaded_frame_size_ = video_frame->natural_size();
+  last_uploaded_frame_timestamp_ = video_frame->timestamp();
   return video_frame;
 }
 
 void WebMediaPlayerImpl::UpdatePlayState() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   bool is_remote = isRemote();
   bool can_auto_suspend = true;
 #else
@@ skipping 473 matching lines @@
 
 void WebMediaPlayerImpl::RecordUnderflowDuration(base::TimeDelta duration) {
   DCHECK(data_source_ || chunk_demuxer_);
   if (data_source_)
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration", duration);
   else
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration.MSE", duration);
 }
 
 }  // namespace media