Revert of 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 5c7e86b6dfe437ac96fd3107b3f7bd787c311493..67aa9b097a3ed7e1755f7f42697bd01a9ab5a5a3 100644
--- a/content/renderer/media/android/webmediaplayer_android.cc
+++ b/content/renderer/media/android/webmediaplayer_android.cc
@@ -135,7 +135,6 @@
       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),
@@ -163,7 +162,7 @@
   if (force_use_overlay_embedded_video_ ||
     player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo()) {
     // Defer stream texture creation until we are sure it's necessary.
-    needs_external_surface_ = true;
+    needs_establish_peer_ = false;
     current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
   }
 #endif  // defined(VIDEO_HOLE)
@@ -304,11 +303,18 @@
 #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_);
@@ -748,6 +754,7 @@
   // 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;
 }
@@ -813,18 +820,25 @@
   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 {
-    needs_external_surface_ = false;
+  } else if (stream_texture_proxy_ && !stream_id_) {
+    // Do deferred stream texture creation finally.
+    DoCreateStreamTexture();
+    SetNeedsEstablishPeer(true);
   }
 #endif  // defined(VIDEO_HOLE)
   natural_size_.width = width;
   natural_size_.height = height;
 
-  // hasVideo() might have changed since play was called, so need to possibly
-  // estlibash peer here.
-  EstablishSurfaceTexturePeerIfNeeded();
+  // 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();
 
   ReallocateVideoFrame();
 
@@ -862,15 +876,16 @@
   DCHECK(!media_source_delegate_);
   DrawRemotePlaybackText(remote_playback_message);
   is_remote_ = true;
-  needs_establish_peer_ = true;
-  EstablishSurfaceTexturePeerIfNeeded();
+  SetNeedsEstablishPeer(false);
 }
 
 void WebMediaPlayerAndroid::OnDisconnectedFromRemoteDevice() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!media_source_delegate_);
+  SetNeedsEstablishPeer(true);
+  if (!paused())
+    EstablishSurfaceTexturePeer();
   is_remote_ = false;
-  EstablishSurfaceTexturePeerIfNeeded();
   ReallocateVideoFrame();
 }
 
@@ -880,8 +895,13 @@
 }
 
 void WebMediaPlayerAndroid::OnDidExitFullscreen() {
-  in_fullscreen_ = false;
-  EstablishSurfaceTexturePeerIfNeeded();
+  // |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();
 
 #if defined(VIDEO_HOLE)
   if (!paused() && needs_external_surface_)
@@ -943,7 +963,9 @@
 }
 
 void WebMediaPlayerAndroid::OnPlayerReleased() {
-  needs_establish_peer_ = true;  // Established when this plays.
+  // |needs_external_surface_| is always false on non-TV devices.
+  if (!needs_external_surface_)
+    needs_establish_peer_ = true;
 
   if (is_playing_)
     OnMediaPlayerPause();
@@ -973,7 +995,8 @@
       break;
   }
   player_manager_->ReleaseResources(player_id_);
-  needs_establish_peer_ = true;  // Established when this plays.
+  if (!needs_external_surface_)
+    SetNeedsEstablishPeer(true);
 }
 
 void WebMediaPlayerAndroid::OnDestruct() {
@@ -1216,17 +1239,32 @@
   if (!stream_texture_factory_)
     return;
 
-  if (needs_external_surface_)
-    return;
-
   stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
-  if (stream_texture_proxy_) {
+  if (needs_establish_peer_ && stream_texture_proxy_) {
     DoCreateStreamTexture();
     ReallocateVideoFrame();
-
-    if (video_frame_provider_client_)
-      stream_texture_proxy_->SetClient(video_frame_provider_client_);
-  }
+  }
+
+  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_;
+  }
+
+  needs_establish_peer_ = false;
 }
 
 void WebMediaPlayerAndroid::DoCreateStreamTexture() {
@@ -1237,21 +1275,8 @@
       kGLTextureExternalOES, &texture_id_, &texture_mailbox_);
 }
 
-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::SetNeedsEstablishPeer(bool needs_establish_peer) {
+  needs_establish_peer_ = needs_establish_peer;
 }
 
 void WebMediaPlayerAndroid::setPoster(const blink::WebURL& poster) {
@@ -1260,7 +1285,6 @@
 
 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
   is_playing_ = is_playing;
-  EstablishSurfaceTexturePeerIfNeeded();
   if (!delegate_)
     return;
   if (is_playing)
@@ -1730,10 +1754,8 @@
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (player_manager_->CanEnterFullscreen(frame_)) {
     player_manager_->EnterFullscreen(player_id_, frame_);
-  }
-  in_fullscreen_ = true;
-  needs_establish_peer_ = true;
-  EstablishSurfaceTexturePeerIfNeeded();
+    SetNeedsEstablishPeer(false);
+  }
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {