Enable seek in fullscreen mode for MSE impl on android

webkit/media/android/webmediaplayer_android.cc

 // Copyright (c) 2012 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 "webkit/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 40 matching lines @@
       buffered_(1u),
       main_loop_(base::MessageLoop::current()),
       pending_seek_(0),
       seeking_(false),
       did_loading_progress_(false),
       manager_(manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       is_playing_(false),
       needs_establish_peer_(true),
+      stream_texture_proxy_initialized_(false),
       has_size_info_(false),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
       proxy_(proxy),
       current_time_(0),
       media_log_(media_log) {
   main_loop_->AddDestructionObserver(this);
   if (manager_)
     player_id_ = manager_->RegisterMediaPlayer(this);
@@ skipping 76 matching lines @@
 }
 
 void WebMediaPlayerAndroid::pause() {
   if (proxy_)
     proxy_->Pause(player_id_);
   is_playing_ = false;
 }
 
 void WebMediaPlayerAndroid::seek(double seconds) {
   pending_seek_ = seconds;
+  if (seeking_ && media_source_delegate_)
+    media_source_delegate_->CancelPendingSeek();
   seeking_ = true;
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
+#if defined(GOOGLE_TV)
+  // TODO(qinmin): check if GTV can also defer the seek until the browser side
+  // player is ready.
   if (media_source_delegate_)
     media_source_delegate_->Seek(seek_time);
+#endif
   if (proxy_)
     proxy_->Seek(player_id_, seek_time);
 }
 
 bool WebMediaPlayerAndroid::supportsFullscreen() const {
   return true;
 }
 
 bool WebMediaPlayerAndroid::supportsSave() const {
   return false;
@@ skipping 319 matching lines @@
 void WebMediaPlayerAndroid::OnMediaPlayerPlay() {
   UpdatePlayingState(true);
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerAndroid::OnMediaPlayerPause() {
   UpdatePlayingState(false);
   client_->playbackStateChanged();
 }
 
+void WebMediaPlayerAndroid::OnMediaSeekRequest(base::TimeDelta time_to_seek,
+                                               bool request_texture_peer) {
+  if (!media_source_delegate_)
+    return;
+
+  if (!seeking_)
+    media_source_delegate_->CancelPendingSeek();
+  media_source_delegate_->Seek(time_to_seek);
+  OnTimeUpdate(time_to_seek);
+  if (request_texture_peer)
+    EstablishSurfaceTexturePeer();
+}
+
 void WebMediaPlayerAndroid::UpdateNetworkState(
     WebMediaPlayer::NetworkState state) {
   network_state_ = state;
   client_->networkStateChanged();
 }
 
 void WebMediaPlayerAndroid::UpdateReadyState(
     WebMediaPlayer::ReadyState state) {
   ready_state_ = state;
   client_->readyStateChanged();
@@ skipping 71 matching lines @@
   if (video_frame_provider_client_)
     video_frame_provider_client_->StopUsingProvider();
   video_frame_provider_client_ = client;
 
   // Set the callback target when a frame is produced.
   if (stream_texture_proxy_)
     stream_texture_proxy_->SetClient(client);
 }
 
 scoped_refptr<media::VideoFrame> WebMediaPlayerAndroid::GetCurrentFrame() {
-  if (stream_texture_proxy_ && !stream_texture_proxy_->IsBoundToThread() &&
+  if (!stream_texture_proxy_initialized_ && stream_texture_proxy_ &&
       stream_id_ && !needs_external_surface_) {
     gfx::Size natural_size = current_frame_->natural_size();
     stream_texture_proxy_->BindToCurrentThread(
         stream_id_, natural_size.width(), natural_size.height());
+    stream_texture_proxy_initialized_ = true;
   }
   return current_frame_;
 }
 
 void WebMediaPlayerAndroid::PutCurrentFrame(
     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_);
+    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;
 }
 
 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
@@ skipping 74 matching lines @@
 void WebMediaPlayerAndroid::exitFullscreen() {
   if (proxy_)
     proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace webkit_media