Send hardware video frames with mailboxes.

content/renderer/media/android/webmediaplayer_android.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/android/webmediaplayer_android.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 65 matching lines @@
       delegate_(delegate),
       buffered_(1u),
       main_loop_(base::MessageLoopProxy::current()),
       ignore_metadata_duration_change_(false),
       pending_seek_(0),
       seeking_(false),
       did_loading_progress_(false),
       manager_(manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
+      texture_id_(0),
+      texture_mailbox_sync_point_(0),
+      stream_id_(0),
       is_playing_(false),
       needs_establish_peer_(true),
       stream_texture_proxy_initialized_(false),
       has_size_info_(false),
       has_media_metadata_(false),
       has_media_info_(false),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
 #if defined(GOOGLE_TV)
@@ skipping 25 matching lines @@
   }
 
   // Defer stream texture creation until we are sure it's necessary.
   stream_id_ = 0;
   needs_establish_peer_ = false;
   current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
 #endif
   if (stream_texture_factory_) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
     if (needs_establish_peer_) {
-      stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
+      stream_id_ = stream_texture_factory_->CreateStreamTexture(
+          kGLTextureExternalOES,
+          &texture_id_,
+          &texture_mailbox_,
+          &texture_mailbox_sync_point_);
       ReallocateVideoFrame();
     }
   }
 
   if (WebKit::WebRuntimeFeatures::isLegacyEncryptedMediaEnabled()) {
     // |decryptor_| is owned, so Unretained() is safe here.
     decryptor_.reset(new ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
         client,
         frame,
@@ skipping 627 matching lines @@
     if (!natural_size_.isEmpty()) {
       current_frame_ = VideoFrame::CreateHoleFrame(natural_size_);
       // Force the client to grab the hole frame.
       client_->repaint();
     }
 #else
     NOTIMPLEMENTED() << "Hole punching not supported outside of Google TV";
 #endif
   } else if (texture_id_) {
     current_frame_ = VideoFrame::WrapNativeTexture(
-        texture_id_, kGLTextureExternalOES, natural_size_,
+        new VideoFrame::MailboxHolder(
+            texture_mailbox_,
+            texture_mailbox_sync_point_,
+            VideoFrame::MailboxHolder::TextureNoLongerNeededCallback()),
+        kGLTextureExternalOES, natural_size_,
         gfx::Rect(natural_size_), natural_size_, base::TimeDelta(),
         VideoFrame::ReadPixelsCB(),
         base::Closure());
   }
 }
 
 void WebMediaPlayerAndroid::SetVideoFrameProviderClient(
     cc::VideoFrameProvider::Client* client) {
   // This is called from both the main renderer thread and the compositor
   // thread (when the main thread is blocked).
@@ skipping 21 matching lines @@
     const scoped_refptr<media::VideoFrame>& frame) {
 }
 
 void WebMediaPlayerAndroid::EstablishSurfaceTexturePeer() {
   if (media_source_delegate_ && stream_texture_factory_) {
     // MediaCodec will release the old surface when it goes away, we need to
     // recreate a new one each time this is called.
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
     stream_id_ = 0;
     texture_id_ = 0;
-    stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
+    texture_mailbox_ = gpu::Mailbox();
+    texture_mailbox_sync_point_ = 0;
+    stream_id_ = stream_texture_factory_->CreateStreamTexture(
+        kGLTextureExternalOES,
+        &texture_id_,
+        &texture_mailbox_,
+        &texture_mailbox_sync_point_);
     ReallocateVideoFrame();
     stream_texture_proxy_initialized_ = false;
   }
   if (stream_texture_factory_.get() && stream_id_)
     stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
   needs_establish_peer_ = false;
 }
 
 void WebMediaPlayerAndroid::SetNeedsEstablishPeer(bool needs_establish_peer) {
   needs_establish_peer_ = needs_establish_peer;
@@ skipping 290 matching lines @@
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content