Clean up WebMediaPlayerAndroid needs_establish_peer_

content/renderer/media/android/webmediaplayer_android.cc

Index: content/renderer/media/android/webmediaplayer_android.cc
diff --git a/content/renderer/media/android/webmediaplayer_android.cc b/content/renderer/media/android/webmediaplayer_android.cc
index 67aa9b097a3ed7e1755f7f42697bd01a9ab5a5a3..5c7e86b6dfe437ac96fd3107b3f7bd787c311493 100644
--- a/content/renderer/media/android/webmediaplayer_android.cc
+++ b/content/renderer/media/android/webmediaplayer_android.cc
@@ -135,6 +135,7 @@ WebMediaPlayerAndroid::WebMediaPlayerAndroid(
       stream_id_(0),
       is_playing_(false),
       needs_establish_peer_(true),
+      in_fullscreen_(false),
       stream_texture_proxy_initialized_(false),
       has_size_info_(false),
       stream_texture_factory_(factory),
@@ -162,7 +163,7 @@ WebMediaPlayerAndroid::WebMediaPlayerAndroid(
   if (force_use_overlay_embedded_video_ ||
     player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo()) {
     // Defer stream texture creation until we are sure it's necessary.
-    needs_establish_peer_ = false;
+    needs_external_surface_ = true;
     current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
   }
 #endif  // defined(VIDEO_HOLE)
@@ -303,18 +304,11 @@ void WebMediaPlayerAndroid::play() {
 #if defined(VIDEO_HOLE)
   if ((hasVideo() || IsHLSStream()) && needs_external_surface_ &&
       !player_manager_->IsInFullscreen(frame_)) {
-    DCHECK(!needs_establish_peer_);
     player_manager_->RequestExternalSurface(player_id_, last_computed_rect_);
   }
 #endif  // defined(VIDEO_HOLE)
 
   TryCreateStreamTextureProxyIfNeeded();
-  // There is no need to establish the surface texture peer for fullscreen
-  // video.
-  if ((hasVideo() || IsHLSStream()) && needs_establish_peer_ &&
-      !player_manager_->IsInFullscreen(frame_)) {
-    EstablishSurfaceTexturePeer();
-  }
 
   if (paused())
     player_manager_->Start(player_id_);
@@ -754,7 +748,6 @@ void WebMediaPlayerAndroid::OnPlaybackComplete() {
   // process are sequential, the OnSeekComplete() will only occur
   // once OnPlaybackComplete() is done. As the playback can only be executed
   // upon completion of OnSeekComplete(), the request needs to be saved.
-  is_playing_ = false;
   if (seeking_ && seek_time_ == base::TimeDelta())
     pending_playback_ = true;
 }
@@ -820,25 +813,18 @@ void WebMediaPlayerAndroid::OnVideoSizeChanged(int width, int height) {
   if (force_use_overlay_embedded_video_ ||
       (media_source_delegate_ && media_source_delegate_->IsVideoEncrypted() &&
        player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo())) {
-    needs_external_surface_ = true;
     if (!paused() && !player_manager_->IsInFullscreen(frame_))
       player_manager_->RequestExternalSurface(player_id_, last_computed_rect_);
-  } else if (stream_texture_proxy_ && !stream_id_) {
-    // Do deferred stream texture creation finally.
-    DoCreateStreamTexture();
-    SetNeedsEstablishPeer(true);
+  } else {
+    needs_external_surface_ = false;
   }
 #endif  // defined(VIDEO_HOLE)
   natural_size_.width = width;
   natural_size_.height = height;
 
-  // When play() gets called, |natural_size_| may still be empty and
-  // EstablishSurfaceTexturePeer() will not get called. As a result, the video
-  // may play without a surface texture. When we finally get the valid video
-  // size here, we should call EstablishSurfaceTexturePeer() if it has not been
-  // previously called.
-  if (!paused() && needs_establish_peer_)
-    EstablishSurfaceTexturePeer();
+  // hasVideo() might have changed since play was called, so need to possibly
+  // estlibash peer here.
+  EstablishSurfaceTexturePeerIfNeeded();
 
   ReallocateVideoFrame();
 
@@ -876,16 +862,15 @@ void WebMediaPlayerAndroid::OnConnectedToRemoteDevice(
   DCHECK(!media_source_delegate_);
   DrawRemotePlaybackText(remote_playback_message);
   is_remote_ = true;
-  SetNeedsEstablishPeer(false);
+  needs_establish_peer_ = true;
+  EstablishSurfaceTexturePeerIfNeeded();
 }
 
 void WebMediaPlayerAndroid::OnDisconnectedFromRemoteDevice() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!media_source_delegate_);
-  SetNeedsEstablishPeer(true);
-  if (!paused())
-    EstablishSurfaceTexturePeer();
   is_remote_ = false;
+  EstablishSurfaceTexturePeerIfNeeded();
   ReallocateVideoFrame();
 }
 
@@ -895,13 +880,8 @@ void WebMediaPlayerAndroid::OnDidEnterFullscreen() {
 }
 
 void WebMediaPlayerAndroid::OnDidExitFullscreen() {
-  // |needs_external_surface_| is always false on non-TV devices.
-  if (!needs_external_surface_)
-    SetNeedsEstablishPeer(true);
-  // We had the fullscreen surface connected to Android MediaPlayer,
-  // so reconnect our surface texture for embedded playback.
-  if (!paused() && needs_establish_peer_)
-    EstablishSurfaceTexturePeer();
+  in_fullscreen_ = false;
+  EstablishSurfaceTexturePeerIfNeeded();
 
 #if defined(VIDEO_HOLE)
   if (!paused() && needs_external_surface_)
@@ -963,9 +943,7 @@ void WebMediaPlayerAndroid::UpdateReadyState(
 }
 
 void WebMediaPlayerAndroid::OnPlayerReleased() {
-  // |needs_external_surface_| is always false on non-TV devices.
-  if (!needs_external_surface_)
-    needs_establish_peer_ = true;
+  needs_establish_peer_ = true;  // Established when this plays.
 
   if (is_playing_)
     OnMediaPlayerPause();
@@ -995,8 +973,7 @@ void WebMediaPlayerAndroid::ReleaseMediaResources() {
       break;
   }
   player_manager_->ReleaseResources(player_id_);
-  if (!needs_external_surface_)
-    SetNeedsEstablishPeer(true);
+  needs_establish_peer_ = true;  // Established when this plays.
 }
 
 void WebMediaPlayerAndroid::OnDestruct() {
@@ -1239,32 +1216,17 @@ void WebMediaPlayerAndroid::TryCreateStreamTextureProxyIfNeeded() {
   if (!stream_texture_factory_)
     return;
 
+  if (needs_external_surface_)
+    return;
+
   stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
-  if (needs_establish_peer_ && stream_texture_proxy_) {
+  if (stream_texture_proxy_) {
     DoCreateStreamTexture();
     ReallocateVideoFrame();
-  }
-
-  if (stream_texture_proxy_ && video_frame_provider_client_)
-    stream_texture_proxy_->SetClient(video_frame_provider_client_);
-}
-
-void WebMediaPlayerAndroid::EstablishSurfaceTexturePeer() {
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-  if (!stream_texture_proxy_)
-    return;
 
-  if (stream_texture_factory_.get() && stream_id_)
-    stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
-
-  // Set the deferred size because the size was changed in remote mode.
-  if (!is_remote_ && cached_stream_texture_size_ != natural_size_) {
-    stream_texture_factory_->SetStreamTextureSize(
-        stream_id_, gfx::Size(natural_size_.width, natural_size_.height));
-    cached_stream_texture_size_ = natural_size_;
+    if (video_frame_provider_client_)
+      stream_texture_proxy_->SetClient(video_frame_provider_client_);
   }
-
-  needs_establish_peer_ = false;
 }
 
 void WebMediaPlayerAndroid::DoCreateStreamTexture() {
@@ -1275,8 +1237,21 @@ void WebMediaPlayerAndroid::DoCreateStreamTexture() {
       kGLTextureExternalOES, &texture_id_, &texture_mailbox_);
 }
 
-void WebMediaPlayerAndroid::SetNeedsEstablishPeer(bool needs_establish_peer) {
-  needs_establish_peer_ = needs_establish_peer;
+void WebMediaPlayerAndroid::EstablishSurfaceTexturePeerIfNeeded() {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  if (!needs_establish_peer_ || in_fullscreen_ || needs_external_surface_ ||
+      is_remote_ || !is_playing_ || !stream_texture_proxy_ ||
+      (!hasVideo() && !IsHLSStream())) {
+    return;
+  }
+
+  stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
+  if (cached_stream_texture_size_ != natural_size_) {
+    stream_texture_factory_->SetStreamTextureSize(
+        stream_id_, gfx::Size(natural_size_.width, natural_size_.height));
+    cached_stream_texture_size_ = natural_size_;
+  }
+  needs_establish_peer_ = false;
 }
 
 void WebMediaPlayerAndroid::setPoster(const blink::WebURL& poster) {
@@ -1285,6 +1260,7 @@ void WebMediaPlayerAndroid::setPoster(const blink::WebURL& poster) {
 
 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
   is_playing_ = is_playing;
+  EstablishSurfaceTexturePeerIfNeeded();
   if (!delegate_)
     return;
   if (is_playing)
@@ -1754,8 +1730,10 @@ void WebMediaPlayerAndroid::SetDecryptorReadyCB(
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (player_manager_->CanEnterFullscreen(frame_)) {
     player_manager_->EnterFullscreen(player_id_, frame_);
-    SetNeedsEstablishPeer(false);
   }
+  in_fullscreen_ = true;
+  needs_establish_peer_ = true;
+  EstablishSurfaceTexturePeerIfNeeded();
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {