Fix a renderer crash when media elements get deleted

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 <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 66 matching lines @@
       pending_play_event_(false),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
       stream_id_(0),
       needs_establish_peer_(true),
       stream_texture_factory_(factory) {
   main_loop_->AddDestructionObserver(this);
   if (manager_)
     player_id_ = manager_->RegisterMediaPlayer(this);
-  if (stream_texture_factory_.get())
+  if (stream_texture_factory_.get()) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
+    stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
+  }
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   if (manager_)
     manager_->UnregisterMediaPlayer(player_id_);
 
+  if (stream_id_)
+    stream_texture_factory_->DestroyStreamTexture(texture_id_);
+
   if (main_loop_)
     main_loop_->RemoveDestructionObserver(this);
 }
 
 void WebMediaPlayerAndroid::InitIncognito(bool incognito_mode) {
   incognito_mode_ = incognito_mode;
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url, CORSMode cors_mode) {
   if (cors_mode != CORSModeUnspecified)
@@ skipping 329 matching lines @@
       break;
   }
   client_->repaint();
 }
 
 void WebMediaPlayerAndroid::OnMediaInfo(int info_type) {
   NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerAndroid::OnVideoSizeChanged(int width, int height) {
+  if (natural_size_.width == width && natural_size_.height == height)
+    return;
+
   natural_size_.width = width;
   natural_size_.height = height;
+  if (texture_id_) {
+    video_frame_.reset(new WebVideoFrameImpl(VideoFrame::WrapNativeTexture(
+        texture_id_, kGLTextureExternalOES, width, height, base::TimeDelta(),
+        base::Closure())));
+  }
 }
 
 void WebMediaPlayerAndroid::UpdateNetworkState(
     WebMediaPlayer::NetworkState state) {
   network_state_ = state;
   client_->networkStateChanged();
 }
 
 void WebMediaPlayerAndroid::UpdateReadyState(
     WebMediaPlayer::ReadyState state) {
@@ skipping 42 matching lines @@
       base::Bind(&WebMediaPlayerProxyAndroid::MediaErrorCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::VideoSizeChangedCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::BufferingUpdateCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::MediaPreparedCallback, proxy_));
 }
 
 void WebMediaPlayerAndroid::PlayInternal() {
   CHECK(prepared_);
 
   if (hasVideo() && stream_texture_factory_.get()) {
-    if (!stream_id_)
-      CreateStreamTexture();
-
     if (needs_establish_peer_) {
       stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
       needs_establish_peer_ = false;
     }
   }
 
   if (paused())
     media_player_->Start(base::Bind(
         &WebMediaPlayerProxyAndroid::PlaybackCompleteCallback, proxy_));
 }
 
 void WebMediaPlayerAndroid::PauseInternal() {
   CHECK(prepared_);
   media_player_->Pause();
 }
 
 void WebMediaPlayerAndroid::SeekInternal(float seconds) {
   CHECK(prepared_);
   seeking_ = true;
   media_player_->SeekTo(ConvertSecondsToTimestamp(seconds), base::Bind(
       &WebMediaPlayerProxyAndroid::SeekCompleteCallback, proxy_));
 }
 
-void WebMediaPlayerAndroid::CreateStreamTexture() {
-  DCHECK(!stream_id_);
-  DCHECK(!texture_id_);
-  stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
-  if (texture_id_)
-    video_frame_.reset(new WebVideoFrameImpl(VideoFrame::WrapNativeTexture(
-        texture_id_,
-        kGLTextureExternalOES,
-        texture_size_.width,
-        texture_size_.height,
-        base::TimeDelta(),
-        base::Bind(&WebMediaPlayerAndroid::DestroyStreamTexture,
-                   base::Unretained(this)))));
-}
-
-void WebMediaPlayerAndroid::DestroyStreamTexture() {
-  DCHECK(stream_id_);
-  DCHECK(texture_id_);
-  stream_texture_factory_->DestroyStreamTexture(texture_id_);
-  texture_id_ = 0;
-  stream_id_ = 0;
-}
-
 void WebMediaPlayerAndroid::WillDestroyCurrentMessageLoop() {
   manager_ = NULL;
   main_loop_ = NULL;
 }
 
 WebVideoFrame* WebMediaPlayerAndroid::getCurrentFrame() {
   if (!stream_texture_proxy_->IsInitialized() && stream_id_) {
     stream_texture_proxy_->Initialize(
         stream_id_, video_frame_->width(), video_frame_->height());
   }
 
   return video_frame_.get();
 }
 
 void WebMediaPlayerAndroid::putCurrentFrame(
     WebVideoFrame* web_video_frame) {
 }
 
 // This gets called both on compositor and main thread.
 void WebMediaPlayerAndroid::setStreamTextureClient(
     WebKit::WebStreamTextureClient* client) {
   if (stream_texture_proxy_.get())
     stream_texture_proxy_->SetClient(client);
 }
 
 }  // namespace webkit_media