Effects Pepper Plugin and MediaStream Glue.

content/renderer/media/video_source_handler.h

+// Copyright (c) 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.
+
+#ifndef CONTENT_RENDERER_MEDIA_VIDEO_SOURCE_HANDLER_H_
+#define CONTENT_RENDERER_MEDIA_VIDEO_SOURCE_HANDLER_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/synchronization/lock.h"
+#include "content/common/content_export.h"
+#include "content/renderer/media/media_stream_registry_interface.h"
+#include "third_party/libjingle/source/talk/app/webrtc/videosourceinterface.h"
+#include "third_party/libjingle/source/talk/media/base/videoframe.h"
+#include "third_party/libjingle/source/talk/media/base/videorenderer.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStream.h"
+
+namespace content {
+
+class MediaStreamDependencyFactory;
+class MediaStreamRegistryInterface;
+
+// Interface used by the effects pepper plugin to get captured frame
+// from the video track.
+class CONTENT_EXPORT FrameReaderInterface {
+ public:
+  // The ownership of the |frame| transfers to the caller. So the caller must
+  // release |frame| when done with it.
+  virtual bool GetFrame(cricket::VideoFrame** frame) = 0;

[wjia(left Chromium), 2013/04/30 18:32:11]

Any reason for pull model here? How does the plugin decide when to call
GetFrame? Since the frames come from cricket::VideoRenderer, would it be better
to use push model to deliver frames to effects plugin?

[Ronghua Wu (Left Chromium), 2013/04/30 22:42:17]

I asked the same question in the pepper host cl, but I didn't get clear answer
yet. Asked again in the design doc.

[dmichael (off chromium), 2013/04/30 23:05:39]

Either model is fine w.r.t. how you hook it up to Pepper. But push might be
easiest. The PPAPI interface is "pull", but it also allows for synchronous or
asynchronous completion. So when you call GetFrame there, if there's not a frame
already waiting, your plugin will get called later when there *is* a frame. But
if a frame *is* ready, you can get it right away, synchronously. So it really
can be used like the push model; the only difference being each time you get a
frame sent to you, you call GetFrame again to schedule the next "push".

To achieve this, we'll want to buffer frames in the proxy (possibly with a
limit, maybe even only keeping the latest frame). The easiest way to put the
frames there is _probably_ by pushing them. We don't want the out-of-process
plugin to "pull" frames across IPC; that would require a synchronous
plugin->renderer call.

Hope that makes sense.

[Ronghua Wu (Left Chromium), 2013/05/01 04:07:31]

Thanks David.

If I understand correctly, for this cl you suggest we have some kind of callback
to deliver the frames to the plugin proxy/host. Then the proxy can return the
frame to the plugin via the callback. Correct?

+
+ protected:
+  virtual ~FrameReaderInterface() {}
+};
+
+// PpFrameReader implements cricket::VideoRenderer so that it can be attached
+// to native video track's video source. It also implements
+// FrameReaderInterface, which will be used by the effects pepper plugin to
+// get the captured frame.
+class CONTENT_EXPORT PpFrameReader
+    : public NON_EXPORTED_BASE(cricket::VideoRenderer),
+      public FrameReaderInterface {
+ public:
+  PpFrameReader();
+  virtual ~PpFrameReader();
+
+  // Implements VideoRenderer.
+  virtual bool SetSize(int width, int height, int reserved) OVERRIDE;
+  virtual bool RenderFrame(const cricket::VideoFrame* frame) OVERRIDE;
+
+  // Implements FrameReaderInterface.
+  virtual bool GetFrame(cricket::VideoFrame** frame) OVERRIDE;
+
+ private:
+  scoped_ptr<cricket::VideoFrame> last_frame_;
+  base::Lock lock_;
+};
+
+// VideoSourceHandler is a glue class between the webrtc MediaStream and
+// the effects pepper plugin host.
+class CONTENT_EXPORT VideoSourceHandler {
+ public:
+  VideoSourceHandler(MediaStreamDependencyFactory* factory,
+                     MediaStreamRegistryInterface* registry);
+  bool Open(const std::string& url, FrameReaderInterface** frame_reader);
+  bool Close(const std::string& url, FrameReaderInterface* frame_reader);

[wjia(left Chromium), 2013/04/30 18:32:11]

Please add detailed comments for public API functions.

[Ronghua Wu (Left Chromium), 2013/04/30 22:42:17]

Done.

+
+ private:
+  scoped_refptr<webrtc::VideoSourceInterface> GetFirstVideoSource(
+      const std::string& url);
+
+  MediaStreamDependencyFactory* factory_;
+  MediaStreamRegistryInterface* registry_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_VIDEO_SOURCE_HANDLER_H_
+