WeakPtr destruction order cleanup: media edition.

media/base/android/media_player_bridge.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 "media/base/android/media_player_bridge.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 16 matching lines @@
 
 MediaPlayerBridge::MediaPlayerBridge(
     int player_id,
     const GURL& url,
     const GURL& first_party_for_cookies,
     const std::string& user_agent,
     bool hide_url_log,
     MediaPlayerManager* manager,
     const RequestMediaResourcesCB& request_media_resources_cb,
     const ReleaseMediaResourcesCB& release_media_resources_cb)
-    : MediaPlayerAndroid(player_id, manager, request_media_resources_cb,
+    : MediaPlayerAndroid(player_id,
+                         manager,
+                         request_media_resources_cb,
                          release_media_resources_cb),
       prepared_(false),
       pending_play_(false),
       url_(url),
       first_party_for_cookies_(first_party_for_cookies),
       user_agent_(user_agent),
       hide_url_log_(hide_url_log),
       width_(0),
       height_(0),
       can_pause_(true),
       can_seek_forward_(true),
       can_seek_backward_(true),
-      weak_this_(this),
-      listener_(base::MessageLoopProxy::current(),
-                weak_this_.GetWeakPtr()),
-      is_surface_in_use_(false) {
+      is_surface_in_use_(false),
+      weak_factory_(this) {
+  listener_.reset(new MediaPlayerListener(base::MessageLoopProxy::current(),
+                                          weak_factory_.GetWeakPtr()));
 }
 
 MediaPlayerBridge::~MediaPlayerBridge() {
   if (!j_media_player_bridge_.is_null()) {
     JNIEnv* env = base::android::AttachCurrentThread();
     CHECK(env);
     Java_MediaPlayerBridge_destroy(env, j_media_player_bridge_.obj());
   }
   Release();
 }
 
 void MediaPlayerBridge::Initialize() {
   cookies_.clear();
   if (url_.SchemeIsFile()) {
     ExtractMediaMetadata(url_.spec());
     return;
   }
 
   media::MediaResourceGetter* resource_getter =
       manager()->GetMediaResourceGetter();
   if (url_.SchemeIsFileSystem() || url_.SchemeIs(kBlobScheme)) {
-    resource_getter->GetPlatformPathFromURL(url_, base::Bind(
-        &MediaPlayerBridge::ExtractMediaMetadata, weak_this_.GetWeakPtr()));
+    resource_getter->GetPlatformPathFromURL(
+        url_,
+        base::Bind(&MediaPlayerBridge::ExtractMediaMetadata,
+                   weak_factory_.GetWeakPtr()));
     return;
   }
 
-  resource_getter->GetCookies(url_, first_party_for_cookies_, base::Bind(
-      &MediaPlayerBridge::OnCookiesRetrieved, weak_this_.GetWeakPtr()));
+  resource_getter->GetCookies(url_,
+                              first_party_for_cookies_,
+                              base::Bind(&MediaPlayerBridge::OnCookiesRetrieved,
+                                         weak_factory_.GetWeakPtr()));
 }
 
 void MediaPlayerBridge::CreateJavaMediaPlayerBridge() {
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   j_media_player_bridge_.Reset(Java_MediaPlayerBridge_create(
       env, reinterpret_cast<intptr_t>(this)));
 
   SetMediaPlayerListener();
@@ skipping 11 matching lines @@
     GetJavaMediaPlayerBridge() {
   base::android::ScopedJavaLocalRef<jobject> j_bridge(
       j_media_player_bridge_);
   return j_bridge;
 }
 
 void MediaPlayerBridge::SetMediaPlayerListener() {
   jobject j_context = base::android::GetApplicationContext();
   DCHECK(j_context);
 
-  listener_.CreateMediaPlayerListener(j_context, j_media_player_bridge_.obj());
+  listener_->CreateMediaPlayerListener(j_context, j_media_player_bridge_.obj());
 }
 
 void MediaPlayerBridge::SetDuration(base::TimeDelta duration) {
   duration_ = duration;
 }
 
 void MediaPlayerBridge::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   if (j_media_player_bridge_.is_null()) {
     if (surface.IsEmpty())
       return;
     Prepare();
   }
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
   is_surface_in_use_ = true;
   Java_MediaPlayerBridge_setSurface(
       env, j_media_player_bridge_.obj(), surface.j_surface().obj());
 }
 
 void MediaPlayerBridge::Prepare() {
   DCHECK(j_media_player_bridge_.is_null());
   CreateJavaMediaPlayerBridge();
   if (url_.SchemeIsFileSystem() || url_.SchemeIs(kBlobScheme)) {
     manager()->GetMediaResourceGetter()->GetPlatformPathFromURL(
-        url_, base::Bind(&MediaPlayerBridge::SetDataSource,
-                         weak_this_.GetWeakPtr()));
+        url_,
+        base::Bind(&MediaPlayerBridge::SetDataSource,
+                   weak_factory_.GetWeakPtr()));
     return;
   }
 
   SetDataSource(url_.spec());
 }
 
 void MediaPlayerBridge::SetDataSource(const std::string& url) {
   if (j_media_player_bridge_.is_null())
     return;
 
@@ skipping 43 matching lines @@
     OnMediaError(MEDIA_ERROR_FORMAT);
 }
 
 void MediaPlayerBridge::OnCookiesRetrieved(const std::string& cookies) {
   cookies_ = cookies;
   ExtractMediaMetadata(url_.spec());
 }
 
 void MediaPlayerBridge::ExtractMediaMetadata(const std::string& url) {
   manager()->GetMediaResourceGetter()->ExtractMediaMetadata(
-      url, cookies_, user_agent_,
+      url,
+      cookies_,
+      user_agent_,
       base::Bind(&MediaPlayerBridge::OnMediaMetadataExtracted,
-                 weak_this_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr()));
 }
 
 void MediaPlayerBridge::OnMediaMetadataExtracted(
     base::TimeDelta duration, int width, int height, bool success) {
   if (success) {
     duration_ = duration;
     width_ = width;
     height_ = height;
   }
   manager()->OnMediaMetadataChanged(
@@ skipping 86 matching lines @@
   if (prepared_)
     pending_seek_ = GetCurrentTime();
   prepared_ = false;
   pending_play_ = false;
   is_surface_in_use_ = false;
   SetVideoSurface(gfx::ScopedJavaSurface());
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_MediaPlayerBridge_release(env, j_media_player_bridge_.obj());
   j_media_player_bridge_.Reset();
   release_media_resources_cb_.Run(player_id());
-  listener_.ReleaseMediaPlayerListenerResources();
+  listener_->ReleaseMediaPlayerListenerResources();
 }
 
 void MediaPlayerBridge::SetVolume(double volume) {
   if (j_media_player_bridge_.is_null())
     return;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
   Java_MediaPlayerBridge_setVolume(
       env, j_media_player_bridge_.obj(), volume);
@@ skipping 140 matching lines @@
 
 GURL MediaPlayerBridge::GetFirstPartyForCookies() {
   return first_party_for_cookies_;
 }
 
 bool MediaPlayerBridge::IsSurfaceInUse() const {
   return is_surface_in_use_;
 }
 
 }  // namespace media