Make stream_id internal to StreamTextureHost.

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 <stddef.h>
 
 #include <limits>
 
@@ skipping 133 matching lines @@
       defer_load_cb_(params.defer_load_cb()),
       buffered_(static_cast<size_t>(1)),
       media_task_runner_(params.media_task_runner()),
       pending_seek_(false),
       seeking_(false),
       did_loading_progress_(false),
       player_manager_(player_manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
-      stream_id_(0),
       is_player_initialized_(false),
       is_playing_(false),
       is_play_pending_(false),
       needs_establish_peer_(true),
       has_size_info_(false),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(params.compositor_task_runner()
                                   ? params.compositor_task_runner()
                                   : base::ThreadTaskRunnerHandle::Get()),
       stream_texture_factory_(factory),
@@ skipping 28 matching lines @@
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   SetVideoFrameProviderClient(NULL);
   client_->setWebLayer(NULL);
 
   if (is_player_initialized_)
     player_manager_->DestroyPlayer(player_id_);
 
   player_manager_->UnregisterMediaPlayer(player_id_);
 
-  if (stream_id_) {
+  if (stream_texture_proxy_.get() && texture_id_) {

[liberato (no reviews please), 2016/10/10 16:46:13]

there are several places where one checks for a stream texture proxy and also
texture id.  it's a little confusing (and was, before this CL, also), since the
stream texture isn't actually used in the block that checks for it.

it's just to make sure that |texture_id_| is defined, i think.  please correct
me if i'm wrong about that.  i didn't see any case where we invalidate
|texture_id_| but don't clear it also.

if StreamTextureProxy guaranteed that it would be zero on failure, or if wmpa
did that, then i think we could just check and clean up |texture_id_|.  it's a
little confusing that one must check |stream_texture_proxy_| to understand if
|texture_id_| is meaningful.

this was an issue before, too.  however, since this CL is generally improving
readability, it would be nice to fix up this too.

[sivag, 2016/10/12 11:25:33]

Done.

     GLES2Interface* gl = stream_texture_factory_->ContextGL();
     gl->DeleteTextures(1, &texture_id_);
     // Flush to ensure that the stream texture gets deleted in a timely fashion.
     gl->ShallowFlushCHROMIUM();
     texture_id_ = 0;
     texture_mailbox_ = gpu::Mailbox();
-    stream_id_ = 0;
   }
 
   {
     base::AutoLock auto_lock(current_frame_lock_);
     current_frame_ = NULL;
   }
 
   if (delegate_) {
     delegate_->PlayerGone(delegate_id_);
     delegate_->RemoveObserver(delegate_id_);
@@ skipping 580 matching lines @@
   // size here, we should call EstablishSurfaceTexturePeer() if it has not been
   // previously called.
   if (!paused() && needs_establish_peer_)
     EstablishSurfaceTexturePeer();
 
   ReallocateVideoFrame();
 
   // For hidden video element (with style "display:none"), ensure the texture
   // size is set.
   if (!is_remote_ && cached_stream_texture_size_ != natural_size_) {
-    stream_texture_factory_->SetStreamTextureSize(
-        stream_id_, gfx::Size(natural_size_.width, natural_size_.height));
+    stream_texture_proxy_->SetStreamTextureSize(
+        gfx::Size(natural_size_.width, natural_size_.height));
     cached_stream_texture_size_ = natural_size_;
   }
 
   // Lazily allocate compositing layer.
   if (!video_weblayer_) {
     video_weblayer_.reset(new cc_blink::WebLayerImpl(
         cc::VideoLayer::Create(this, media::VIDEO_ROTATION_0)));
     client_->setWebLayer(video_weblayer_.get());
 
     // If we're paused after we receive metadata for the first time, tell the
@@ skipping 281 matching lines @@
 
   return video_frame;
 }
 
 void WebMediaPlayerAndroid::PutCurrentFrame() {
 }
 
 void WebMediaPlayerAndroid::RemoveSurfaceTextureAndProxy() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  if (stream_id_) {
+  if (stream_texture_proxy_.get() && texture_id_) {
     GLES2Interface* gl = stream_texture_factory_->ContextGL();
     gl->DeleteTextures(1, &texture_id_);
     // Flush to ensure that the stream texture gets deleted in a timely fashion.
     gl->ShallowFlushCHROMIUM();
     texture_id_ = 0;
     texture_mailbox_ = gpu::Mailbox();
-    stream_id_ = 0;
   }
   stream_texture_proxy_.reset();
   needs_establish_peer_ =
       !is_remote_ && !is_fullscreen_ && (hasVideo() || IsHLSStream());
 }
 
 void WebMediaPlayerAndroid::UpdateStreamTextureProxyCallback(
     cc::VideoFrameProvider::Client* client) {
   base::Closure frame_received_cb;
 
   if (client) {
     // Unretained is safe here because:
     // - |client| is valid until we receive a call to
     // SetVideoFrameProviderClient(nullptr).
     // - SetVideoFrameProviderClient(nullptr) clears proxy's callback
     // guaranteeing it will no longer be run.
     frame_received_cb =
         base::Bind(&cc::VideoFrameProvider::Client::DidReceiveFrame,
                    base::Unretained(client));
   }
 
-  stream_texture_proxy_->BindToTaskRunner(stream_id_, frame_received_cb,
+  stream_texture_proxy_->BindToTaskRunner(frame_received_cb,
                                           compositor_task_runner_);
 }
 
 void WebMediaPlayerAndroid::TryCreateStreamTextureProxyIfNeeded() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Already created.
   if (stream_texture_proxy_)
     return;
 
   // No factory to create proxy.
   if (!stream_texture_factory_.get())
     return;
 
   // Not needed for hole punching.
   if (!needs_establish_peer_)
     return;
 
-  stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
-  if (stream_texture_proxy_) {
-    DoCreateStreamTexture();
-    ReallocateVideoFrame();
-    if (video_frame_provider_client_)
-      UpdateStreamTextureProxyCallback(video_frame_provider_client_);
-  }
+  DCHECK(!texture_id_);
+  stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy(
+      kGLTextureExternalOES, &texture_id_, &texture_mailbox_));
+  if (!stream_texture_proxy_)
+    return;

[liberato (no reviews please), 2016/10/10 16:46:13]

this is where one might set |texture_id_| to zero, if StreamTextureProxy doesn't
guarantee it.

+  ReallocateVideoFrame();
+  if (video_frame_provider_client_)
+    UpdateStreamTextureProxyCallback(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_, frame_id_);
+  stream_texture_proxy_->EstablishPeer(player_id_, frame_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));
+    stream_texture_proxy_->SetStreamTextureSize(
+        gfx::Size(natural_size_.width, natural_size_.height));
     cached_stream_texture_size_ = natural_size_;
   }
 
   needs_establish_peer_ = false;
 }
 
-void WebMediaPlayerAndroid::DoCreateStreamTexture() {
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-  DCHECK(!stream_id_);
-  DCHECK(!texture_id_);
-  stream_id_ = stream_texture_factory_->CreateStreamTexture(
-      kGLTextureExternalOES, &texture_id_, &texture_mailbox_);
-}
-
 void WebMediaPlayerAndroid::SetNeedsEstablishPeer(bool needs_establish_peer) {
   needs_establish_peer_ = needs_establish_peer;
 }
 
 void WebMediaPlayerAndroid::setPoster(const blink::WebURL& poster) {
   player_manager_->SetPoster(player_id_, poster);
 }
 
 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
   if (is_playing == is_playing_)
@@ skipping 130 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableMediaSuspend)) {
     return false;
   }
 
   return base::FeatureList::IsEnabled(media::kResumeBackgroundVideo) &&
       hasAudio() && !isRemote() && delegate_ && delegate_->IsHidden();
 }
 
 }  // namespace content