Update StreamTextureProxy to accept a base::Closure

content/renderer/media/android/stream_texture_wrapper_impl.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_WRAPPER_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_WRAPPER_IMPL_H_
 
 #include <memory>
 
 #include "content/common/content_export.h"
 #include "content/renderer/media/android/stream_texture_factory.h"
 #include "gpu/command_buffer/common/mailbox.h"
+#include "media/base/android/stream_texture_wrapper.h"
 #include "media/base/video_frame.h"
-#include "media/blink/stream_texture_wrapper.h"
 
 namespace content {
 
 // Concrete implementation of StreamTextureWrapper. Any method can be called on
 // any thread, but additional threading considerations are listed in the
 // comments of individual methods.
 //
 // The StreamTexture is an abstraction allowing Chrome to wrap a SurfaceTexture
 // living in the GPU process. It allows VideoFrames to be created from the
 // SurfaceTexture's texture, in the Renderer process.
@@ skipping 31 matching lines @@
   // Creates the underlying StreamTexture, and binds |stream_texture_proxy_| to
   // |compositor_task_runner|.
   //
   // Additional threading considerations:
   //   - Can be called from any thread.
   //   - Initialization will be posted to |main_task_runner_|.
   //   - |init_cb| will be run on the calling thread.
   //   - New frames will be signaled on |compositor_task_runner| via |client|'s
   //     DidReceiveFrame() method.
   void 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) override;
 
   // Should be called when the Video size changes.
   // Can be called from any thread, but runs on |main_task_runner_|.
   void UpdateTextureSize(const gfx::Size& natural_size) override;
 
   // Returns the latest frame.
   // N.B: We create a single VideoFrame at initialization time (and update it
   // in UpdateTextureSize()), and repeatedly return it here. The underlying
   // texture's changes are signalled via |client|'s DidReceiveFrame() callback.
   scoped_refptr<media::VideoFrame> GetCurrentFrame() override;
 
  private:
   StreamTextureWrapperImpl(
       scoped_refptr<StreamTextureFactory> factory,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
   ~StreamTextureWrapperImpl() override;
 
   // Destroys |this| safely on |main_task_runner_|.
   void Destroy() override;
 
-  void InitializeOnMainThread(cc::VideoFrameProvider::Client* client,
+  void InitializeOnMainThread(const base::Closure& received_frame_cb,
                               const base::Closure& init_cb);
 
   void ReallocateVideoFrame(const gfx::Size& natural_size);
 
   void SetCurrentFrameInternal(
       const scoped_refptr<media::VideoFrame>& video_frame);
 
   // Client GL texture ID allocated to the StreamTexture.
   unsigned texture_id_;
 
@@ skipping 19 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
 
   base::WeakPtrFactory<StreamTextureWrapperImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamTextureWrapperImpl);
 };
 
 }  // namespace media
 
 #endif  // CONTENT_RENDERER_MEDIA_ANDROID_STREAM_TEXTURE_WRAPPER_IMPL_H_