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..92b25ab3379e6b5fe9d6100721c003c0dbc0807b 100644
--- a/content/renderer/media/android/webmediaplayer_android.cc
+++ b/content/renderer/media/android/webmediaplayer_android.cc
@@ -134,7 +134,8 @@ WebMediaPlayerAndroid::WebMediaPlayerAndroid(
       texture_id_(0),
       stream_id_(0),
       is_playing_(false),
-      needs_establish_peer_(true),
+      peer_established_(false),
+      in_fullscreen_(false),
       stream_texture_proxy_initialized_(false),
       has_size_info_(false),
       stream_texture_factory_(factory),
@@ -161,8 +162,8 @@ WebMediaPlayerAndroid::WebMediaPlayerAndroid(
       HasSwitch(switches::kForceUseOverlayEmbeddedVideo);
   if (force_use_overlay_embedded_video_ ||
     player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo()) {
+    needs_external_surface_ = true;
     // Defer stream texture creation until we are sure it's necessary.
-    needs_establish_peer_ = false;
     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_);
@@ -820,25 +814,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 +863,15 @@ void WebMediaPlayerAndroid::OnConnectedToRemoteDevice(
   DCHECK(!media_source_delegate_);
   DrawRemotePlaybackText(remote_playback_message);
   is_remote_ = true;
-  SetNeedsEstablishPeer(false);
+  peer_established_ = false;
+  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 +881,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 +944,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;
+  peer_established_ = false;  // Established when this plays.
 
   if (is_playing_)
     OnMediaPlayerPause();
@@ -995,8 +974,7 @@ void WebMediaPlayerAndroid::ReleaseMediaResources() {
       break;
   }
   player_manager_->ReleaseResources(player_id_);
-  if (!needs_external_surface_)
-    SetNeedsEstablishPeer(true);
+  peer_established_ = false;  // Established when this plays.
 }
 
 void WebMediaPlayerAndroid::OnDestruct() {
@@ -1239,32 +1217,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 +1238,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 (peer_established_ || 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_;
+  }
+  peer_established_ = true;
 }
 
 void WebMediaPlayerAndroid::setPoster(const blink::WebURL& poster) {
@@ -1285,6 +1261,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 +1731,10 @@ void WebMediaPlayerAndroid::SetDecryptorReadyCB(
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (player_manager_->CanEnterFullscreen(frame_)) {
     player_manager_->EnterFullscreen(player_id_, frame_);
-    SetNeedsEstablishPeer(false);
   }
+  in_fullscreen_ = true;
+  peer_established_ = false;
+  EstablishSurfaceTexturePeerIfNeeded();
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {