Update StreamTextureProxy to accept a base::Closure

content/renderer/media/android/stream_texture_factory.cc

 // Copyright 2014 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/stream_texture_factory.h"
 
 #include "base/macros.h"
 #include "cc/output/context_provider.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
-StreamTextureProxy::StreamTextureProxy(StreamTextureHost* host)
-    : host_(host), client_(NULL) {}
+StreamTextureProxy::StreamTextureProxy(StreamTextureHost* host) : host_(host) {}
 
 StreamTextureProxy::~StreamTextureProxy() {}
 
 void StreamTextureProxy::Release() {
   {
     // Cannot call into |client_| anymore (from any thread) after returning

[watk, 2016/07/29 19:03:16]

|client_| is dead

[tguilbert, 2016/08/01 22:05:57]

Done.

     // from here.
     base::AutoLock lock(lock_);
-    client_ = NULL;
+    received_frame_cb_.Reset();
   }
   // Release is analogous to the destructor, so there should be no more external
   // calls to this object in Release. Therefore there is no need to acquire the
   // lock to access |loop_|.
   if (!loop_.get() || loop_->BelongsToCurrentThread() ||
       !loop_->DeleteSoon(FROM_HERE, this)) {
     delete this;
   }
 }
 
 void StreamTextureProxy::BindToLoop(
     int32_t stream_id,
-    cc::VideoFrameProvider::Client* client,
+    const base::Closure& received_frame_cb,
     scoped_refptr<base::SingleThreadTaskRunner> loop) {
   DCHECK(loop.get());
 
   {
     base::AutoLock lock(lock_);
     DCHECK(!loop_.get() || (loop.get() == loop_.get()));
     loop_ = loop;
-    client_ = client;
+    received_frame_cb_ = received_frame_cb;
   }
 
   if (loop->BelongsToCurrentThread()) {
     BindOnThread(stream_id);
     return;
   }
   // Unretained is safe here only because the object is deleted on |loop_|
   // thread.
   loop->PostTask(FROM_HERE,
                  base::Bind(&StreamTextureProxy::BindOnThread,
                             base::Unretained(this),
                             stream_id));
 }
 
 void StreamTextureProxy::BindOnThread(int32_t stream_id) {
   host_->BindToCurrentThread(stream_id, this);
 }
 
 void StreamTextureProxy::OnFrameAvailable() {
   base::AutoLock lock(lock_);
-  if (client_)
-    client_->DidReceiveFrame();
+  if (!received_frame_cb_.is_null())
+    received_frame_cb_.Run();
 }
 
 // static
 scoped_refptr<StreamTextureFactory> StreamTextureFactory::Create(
     scoped_refptr<ContextProviderCommandBuffer> context_provider) {
   return new StreamTextureFactory(std::move(context_provider));
 }
 
 StreamTextureFactory::StreamTextureFactory(
     scoped_refptr<ContextProviderCommandBuffer> context_provider)
@@ skipping 35 matching lines @@
 void StreamTextureFactory::SetStreamTextureSize(int32_t stream_id,
                                                     const gfx::Size& size) {
   channel_->Send(new GpuStreamTextureMsg_SetSize(stream_id, size));
 }
 
 gpu::gles2::GLES2Interface* StreamTextureFactory::ContextGL() {
   return context_provider_->ContextGL();
 }
 
 }  // namespace content