Update StreamTextureProxy to accept a base::Closure

content/renderer/media/android/stream_texture_wrapper_impl.cc

 // Copyright 2016 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_wrapper_impl.h"
 
 #include "base/callback.h"
 #include "cc/layers/video_frame_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
@@ skipping 112 matching lines @@
   if (natural_size_ == new_size)
     return;
 
   natural_size_ = new_size;
 
   ReallocateVideoFrame(new_size);
   factory_->SetStreamTextureSize(stream_id_, new_size);
 }
 
 void StreamTextureWrapperImpl::Initialize(
-    cc::VideoFrameProvider::Client* client,
+    const base::Closure& received_frame_cb,
     const gfx::Size& natural_size,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     const base::Closure& init_cb) {
   DVLOG(2) << __FUNCTION__;
 
   compositor_task_runner_ = compositor_task_runner;
   natural_size_ = natural_size;
 
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&StreamTextureWrapperImpl::InitializeOnMainThread,
-                            weak_factory_.GetWeakPtr(), client,
+                            weak_factory_.GetWeakPtr(), received_frame_cb,
                             media::BindToCurrentLoop(init_cb)));
 }
 
 void StreamTextureWrapperImpl::InitializeOnMainThread(
-    cc::VideoFrameProvider::Client* client,
+    const base::Closure& received_frame_cb,
     const base::Closure& init_cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(2) << __FUNCTION__;
 
   stream_texture_proxy_.reset(factory_->CreateProxy());
 
   stream_id_ = factory_->CreateStreamTexture(kGLTextureExternalOES,
                                              &texture_id_, &texture_mailbox_);
   ReallocateVideoFrame(natural_size_);
 
-  stream_texture_proxy_->BindToLoop(stream_id_, client,
-                                    compositor_task_runner_);
+  stream_texture_proxy_->BindToTaskRunner(stream_id_, received_frame_cb,
+                                          compositor_task_runner_);
 
   // TODO(tguilbert): Register the surface properly. See crbug.com/627658.
 
   // |init_cb| is bound to the thread that originally called Initialize().
   init_cb.Run();
 }
 
 void StreamTextureWrapperImpl::Destroy() {
-  // Note: StreamTextureProxy will release its reference to |client|
-  // immediately (and stop calling back DidReceiveFrame()).
+  // Note: StreamTextureProxy stop calling back the provided frame received
+  // callback immediately, and delete itself on the right thread.
   stream_texture_proxy_.reset();
 
   if (!main_task_runner_->BelongsToCurrentThread()) {
     // base::Unretained is safe here because this function is the only one that
     // can can call delete.
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&StreamTextureWrapperImpl::Destroy, base::Unretained(this)));
     return;
   }
 
   delete this;
 }
 
 }  // namespace content