Add StreamTextureWrapper/StreamTextureWrapperImpl

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/video_frame.h"
+#include "media/blink/stream_texture_wrapper.h"
+
+namespace content {
+
+// Concrete implementation of StreamTextureWrapper. Can be created on any,
+// thread, but will be initialized/destroyed on |main_tread_task_runner|, and

[watk, 2016/07/23 03:13:39]

typo: main_tread_task_runner
Remove comma in "any, thread,"
nit: The threading contract could be clearer. i.e., that you can basically call
all methods on any thread.

[tguilbert, 2016/07/26 00:13:51]

Done.

+// will signal the readyness of new frames on |compositor_task_runner_|.

[watk, 2016/07/23 03:13:40]

readiness

[tguilbert, 2016/07/26 00:13:51]

Done.

+//
+// A SurfaceTexture is an Android primitive, joining an Android Surface (the
+// producer side, used by MediaPlayer for example) with a GL Texture (the
+// consumer side, used by our compositor). Its documentation can be found here:
+// https://developer.android.com/reference/android/graphics/SurfaceTexture.html

[watk, 2016/07/23 03:13:40]

nit: doesn't feel like the right place to describe SurfaceTexture, but up to you
if you want to keep it.

[tguilbert, 2016/07/26 00:13:52]

I'm fine with removing this.

+//
+// 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.
+//
+// The general idea behind our use of StreamTexture is as follows:
+// - We create a client GL texture in the Renderer process.
+// - We request the creation of a StreamTexture via the StreamTextureFactory,
+// passing the client texture ID. The call is sent to the GPU process via the
+// CommandBuffer. The "platform" GL texture reference associated with the client
+// texture ID is looked up in the TextureManager. A StreamTexture is then
+// created, wrapping a SurfaceTexture created from the texture reference. The
+// SurfaceTexture's OnFrameAvailable() callback is tied to StreamTexture's
+// OnFrameAvailable(), which fires an IPC accross the GPU channel.
+// - We create a StreamTextureProxy in the Renderer process which listens for
+// the IPC fired by the StreamTexture's OnFrameAvailable() callback.
+// - We bind the StreamTextureProxy's lifetime to the |compositor_task_runner_|.
+// - We wrap the client texture into a VideoFrame.
+// - When the SurfaceTexture's OnFrameAvailable() callback is fired (and routed
+// to the StreamTextureProxy living on the compositor thread), we notify
+// |client_| that a new frame is available, via the DidReceiveFrame() callback.
+//
+// TODO(tguilbert): Register the underlying SurfaceTexture for retrieval in the
+// browser process. See crbug.com/627658.
+//
+class CONTENT_EXPORT StreamTextureWrapperImpl
+    : public media::StreamTextureWrapper {
+ public:
+  StreamTextureWrapperImpl(
+      scoped_refptr<StreamTextureFactory> factory,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
+  virtual ~StreamTextureWrapperImpl();
+
+  // StreamTextureWrapper implementation.

[watk, 2016/07/23 03:13:40]

Since you're only implementing one interface now, you can probably delete this
comment.

[tguilbert, 2016/07/26 00:13:52]

Done.

+
+  // Creates the underlying StreamTexture. Binds |client|'s DidReceiveFrame() to
+  // |compositor_task_runner|.

[watk, 2016/07/23 03:13:40]

Second sentence isn't super clear. It's the proxy that's being set up/bound.

[tguilbert, 2016/07/26 00:13:52]

Done.

+  // Can be called from any thread, but runs on |main_task_runner_|.
+  void Initialize(
+      cc::VideoFrameProvider::Client* client,
+      const gfx::Size& natural_size,
+      scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
+      const base::Closure& init_cb) override;
+
+  // 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;
+
+  // Destroys the StreamTextureWrapper safely on the |main_task_runner_|.

[watk, 2016/07/23 03:13:40]

StreamTextureWrapperImpl. Or even better, |this|.

[tguilbert, 2016/07/26 00:13:52]

Done.

+  void Destroy() override;
+
+ private:
+  void InitializeOnMainThread(const base::Closure& init_cb);
+
+  void ReallocateVideoFrame(const gfx::Size& natural_size);
+
+  void SetCurrentFrameInternal(
+      const scoped_refptr<media::VideoFrame>& video_frame);
+
+  // GL texture ID allocated to the video.
+  unsigned int texture_id_;
+
+  // GL texture mailbox for |texture_id_| to provide in the VideoFrame, and sync
+  // point for when the mailbox was produced.

[watk, 2016/07/23 03:13:40]

There's no sync point here?

[tguilbert, 2016/07/26 00:13:52]

Removed that part from the comment (which came from WMPA).

+  gpu::Mailbox texture_mailbox_;
+
+  // Stream texture ID allocated to the video.
+  unsigned int stream_id_;
+
+  // Object for calling back the compositor thread to repaint the video when a
+  // frame available. It should be bound to the compositor thread.

[watk, 2016/07/23 03:13:39]

frame _is_ available

[tguilbert, 2016/07/26 00:13:51]

Done.

+  ScopedStreamTextureProxy stream_texture_proxy_;
+
+  cc::VideoFrameProvider::Client* client_;

[watk, 2016/07/23 03:13:40]

Looks like you don't need this after Initialize().

[tguilbert, 2016/07/26 00:13:52]

Ack. Removed from member variables and added to the Initialize().

+
+  // Size of the allocated underlying texture.
+  gfx::Size natural_size_;

[watk, 2016/07/23 03:13:40]

This is not used to allocate a texture though. The most important thing is it's
the size of the video frames.

[tguilbert, 2016/07/26 00:13:51]

Done.

+
+  scoped_refptr<StreamTextureFactory> factory_;
+
+  base::Lock current_frame_lock_;
+  scoped_refptr<media::VideoFrame> current_frame_;
+
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+  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_