Replace SupportsWeakPtr with WeakPtrFactory in VideoResourceUpdater

cc/resources/video_resource_updater.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 "cc/resources/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 160 matching lines @@
 VideoFrameExternalResources::VideoFrameExternalResources(
     const VideoFrameExternalResources& other) = default;
 
 VideoFrameExternalResources::~VideoFrameExternalResources() {}
 
 VideoResourceUpdater::VideoResourceUpdater(ContextProvider* context_provider,
                                            ResourceProvider* resource_provider,
                                            bool use_stream_video_draw_quad)
     : context_provider_(context_provider),
       resource_provider_(resource_provider),
-      use_stream_video_draw_quad_(use_stream_video_draw_quad) {}
+      use_stream_video_draw_quad_(use_stream_video_draw_quad),
+      weak_ptr_factory_(this) {}
 
 VideoResourceUpdater::~VideoResourceUpdater() {
   for (const PlaneResource& plane_resource : all_resources_)
     resource_provider_->DeleteResource(plane_resource.resource_id());
 }
 
 VideoResourceUpdater::ResourceList::iterator
 VideoResourceUpdater::RecycleOrAllocateResource(
     const gfx::Size& resource_size,
     ResourceFormat resource_format,
@@ skipping 222 matching lines @@
         resource_provider_->CopyToResource(plane_resource.resource_id(),
                                            &upload_pixels_[0],
                                            plane_resource.resource_size());
       }
       plane_resource.SetUniqueId(video_frame->unique_id(), 0);
     }
 
     if (software_compositor) {
       external_resources.software_resources.push_back(
           plane_resource.resource_id());
-      external_resources.software_release_callback = base::Bind(
-          &RecycleResource, AsWeakPtr(), plane_resource.resource_id());
+      external_resources.software_release_callback =
+          base::Bind(&RecycleResource, weak_ptr_factory_.GetWeakPtr(),
+                     plane_resource.resource_id());
       external_resources.type = VideoFrameExternalResources::SOFTWARE_RESOURCE;
     } else {
       // VideoResourceUpdater shares a context with the compositor so
       // a sync token is not required.
       TextureMailbox mailbox(plane_resource.mailbox(), gpu::SyncToken(),
                              resource_provider_->GetResourceTextureTarget(
                                  plane_resource.resource_id()));
       mailbox.set_color_space(output_color_space);
       external_resources.mailboxes.push_back(mailbox);
-      external_resources.release_callbacks.push_back(base::Bind(
-          &RecycleResource, AsWeakPtr(), plane_resource.resource_id()));
+      external_resources.release_callbacks.push_back(
+          base::Bind(&RecycleResource, weak_ptr_factory_.GetWeakPtr(),
+                     plane_resource.resource_id()));
       external_resources.type = VideoFrameExternalResources::RGBA_RESOURCE;
     }
     return external_resources;
   }
 
   std::unique_ptr<media::HalfFloatMaker> half_float_maker;
   if (resource_provider_->YuvResourceFormat(bits_per_channel) ==
       LUMINANCE_F16) {
     half_float_maker =
         media::HalfFloatMaker::NewHalfFloatMaker(bits_per_channel);
@@ skipping 81 matching lines @@
       plane_resource.SetUniqueId(video_frame->unique_id(), i);
     }
 
     // VideoResourceUpdater shares a context with the compositor so a
     // sync token is not required.
     TextureMailbox mailbox(plane_resource.mailbox(), gpu::SyncToken(),
                            resource_provider_->GetResourceTextureTarget(
                                plane_resource.resource_id()));
     mailbox.set_color_space(output_color_space);
     external_resources.mailboxes.push_back(mailbox);
-    external_resources.release_callbacks.push_back(base::Bind(
-        &RecycleResource, AsWeakPtr(), plane_resource.resource_id()));
+    external_resources.release_callbacks.push_back(
+        base::Bind(&RecycleResource, weak_ptr_factory_.GetWeakPtr(),
+                   plane_resource.resource_id()));
   }
 
   external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::ReturnTexture(
     base::WeakPtr<VideoResourceUpdater> updater,
     const scoped_refptr<media::VideoFrame>& video_frame,
@@ skipping 55 matching lines @@
   video_frame->UpdateReleaseSyncToken(&client);
 
   // VideoResourceUpdater shares a context with the compositor so a
   // sync token is not required.
   TextureMailbox mailbox(resource->mailbox(), gpu::SyncToken(), GL_TEXTURE_2D,
                          video_frame->coded_size(), false, false);
   mailbox.set_color_space(resource_color_space);
   external_resources->mailboxes.push_back(mailbox);
 
   external_resources->release_callbacks.push_back(
-      base::Bind(&RecycleResource, AsWeakPtr(), resource->resource_id()));
+      base::Bind(&RecycleResource, weak_ptr_factory_.GetWeakPtr(),
+                 resource->resource_id()));
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForHardwarePlanes");
   DCHECK(video_frame->HasTextures());
   if (!context_provider_)
     return VideoFrameExternalResources();
 
   VideoFrameExternalResources external_resources;
@@ skipping 31 matching lines @@
                                  media::VideoFrameMetadata::ALLOW_OVERLAY),
                              false);
       mailbox.set_color_space(resource_color_space);
 #if defined(OS_ANDROID)
       mailbox.set_is_backed_by_surface_texture(video_frame->metadata()->IsTrue(
           media::VideoFrameMetadata::SURFACE_TEXTURE));
       mailbox.set_wants_promotion_hint(video_frame->metadata()->IsTrue(
           media::VideoFrameMetadata::WANTS_PROMOTION_HINT));
 #endif
       external_resources.mailboxes.push_back(mailbox);
-      external_resources.release_callbacks.push_back(
-          base::Bind(&ReturnTexture, AsWeakPtr(), video_frame));
+      external_resources.release_callbacks.push_back(base::Bind(
+          &ReturnTexture, weak_ptr_factory_.GetWeakPtr(), video_frame));
     }
   }
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     ResourceId resource_id,
     const gpu::SyncToken& sync_token,
@@ skipping 20 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc