[PPAPI] Add media stream video track output API

Implemented the pepper host for the output mode.

R=bbudge@chromium.org, dmichael@chromium.org, jschuh@chromium.org, yzshen@chromium.org

Review URL: https://codereview.chromium.org/145263008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@268318 0039d316-1c4b-4281-b951-d872f2087c98

21 files changed, 397 insertions, 31 deletions

diff --git a/ppapi/api/ppb_media_stream_video_track.idl b/ppapi/api/ppb_media_stream_video_track.idl
index 91e95026..2cf8530 100644
--- a/ppapi/api/ppb_media_stream_video_track.idl
+++ b/ppapi/api/ppb_media_stream_video_track.idl
@@ -12,7 +12,8 @@
 
 label Chrome {
   [channel=dev] M34 = 0.1,
-  M35 = 0.1
+  M35 = 0.1,
+  [channel=dev] M36 = 1.0
 };
 
 /**
@@ -74,6 +75,19 @@ enum PP_MediaStreamVideoTrack_Attrib {
 [version=0.1]
 interface PPB_MediaStreamVideoTrack {
   /**
+   * Creates a PPB_MediaStreamVideoTrack resource for video output. Call this
+   * when you will be creating frames and putting them to the track.
+   *
+   * @param[in] instance A <code>PP_Instance</code> identifying one instance of
+   * a module.
+   *
+   * @return A <code>PP_Resource</code> corresponding to a
+   * PPB_MediaStreamVideoTrack resource if successful, 0 if failed.
+   */
+  [version=1.0]
+  PP_Resource Create([in] PP_Instance instance);
+
+  /**
    * Determines if a resource is a MediaStream video track resource.
    *
    * @param[in] resource The <code>PP_Resource</code> to test.
@@ -211,5 +225,23 @@ interface PPB_MediaStreamVideoTrack {
    * MediaStream video track resource.
    */
   void Close([in] PP_Resource video_track);
+
+  /**
+   * Gets a free frame for output. The frame is allocated by
+   * <code>Configure()</code>. The caller should fill it with frame data, and
+   * then use |PutFrame()| to send the frame back.
+   */
+  [version=1.0]
+  int32_t GetEmptyFrame([in] PP_Resource video_track,
+                        [out] PP_Resource frame,
+                        [in] PP_CompletionCallback callback);
+
+  /**
+   * Sends a frame returned by |GetEmptyFrame()| to the output track.
+   * After this function, the |frame| should not be used anymore and the
+   * caller should release the reference that it holds.
+   */
+  [version=1.0]
+  int32_t PutFrame([in] PP_Resource video_track, [in] PP_Resource frame);
 };
 
diff --git a/ppapi/c/pp_macros.h b/ppapi/c/pp_macros.h
index 61be3d0..ae27731 100644
--- a/ppapi/c/pp_macros.h
+++ b/ppapi/c/pp_macros.h
@@ -3,13 +3,13 @@
  * found in the LICENSE file.
  */
 
-/* From pp_macros.idl modified Wed Feb 26 15:01:03 2014. */
+/* From pp_macros.idl modified Thu Jan 23 14:14:38 2014. */
 
 #ifndef PPAPI_C_PP_MACROS_H_
 #define PPAPI_C_PP_MACROS_H_
 
 
-#define PPAPI_RELEASE 35
+#define PPAPI_RELEASE 36
 
 /**
  * @file
diff --git a/ppapi/c/ppb_media_stream_video_track.h b/ppapi/c/ppb_media_stream_video_track.h
index 1580041..31c7a80 100644
--- a/ppapi/c/ppb_media_stream_video_track.h
+++ b/ppapi/c/ppb_media_stream_video_track.h
@@ -3,19 +3,22 @@
  * found in the LICENSE file.
  */
 
-/* From ppb_media_stream_video_track.idl modified Fri Mar 28 10:13:52 2014. */
+/* From ppb_media_stream_video_track.idl modified Mon Apr  7 15:25:56 2014. */
 
 #ifndef PPAPI_C_PPB_MEDIA_STREAM_VIDEO_TRACK_H_
 #define PPAPI_C_PPB_MEDIA_STREAM_VIDEO_TRACK_H_
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_macros.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/c/pp_var.h"
 
 #define PPB_MEDIASTREAMVIDEOTRACK_INTERFACE_0_1 "PPB_MediaStreamVideoTrack;0.1"
+#define PPB_MEDIASTREAMVIDEOTRACK_INTERFACE_1_0 \
+    "PPB_MediaStreamVideoTrack;1.0" /* dev */
 #define PPB_MEDIASTREAMVIDEOTRACK_INTERFACE \
     PPB_MEDIASTREAMVIDEOTRACK_INTERFACE_0_1
 
@@ -89,7 +92,18 @@ typedef enum {
  * @addtogroup Interfaces
  * @{
  */
-struct PPB_MediaStreamVideoTrack_0_1 {
+struct PPB_MediaStreamVideoTrack_1_0 { /* dev */
+  /**
+   * Creates a PPB_MediaStreamVideoTrack resource for video output. Call this
+   * when you will be creating frames and putting them to the track.
+   *
+   * @param[in] instance A <code>PP_Instance</code> identifying one instance of
+   * a module.
+   *
+   * @return A <code>PP_Resource</code> corresponding to a
+   * PPB_MediaStreamVideoTrack resource if successful, 0 if failed.
+   */
+  PP_Resource (*Create)(PP_Instance instance);
   /**
    * Determines if a resource is a MediaStream video track resource.
    *
@@ -219,6 +233,37 @@ struct PPB_MediaStreamVideoTrack_0_1 {
    * MediaStream video track resource.
    */
   void (*Close)(PP_Resource video_track);
+  /**
+   * Gets a free frame for output. The frame is allocated by
+   * <code>Configure()</code>. The caller should fill it with frame data, and
+   * then use |PutFrame()| to send the frame back.
+   */
+  int32_t (*GetEmptyFrame)(PP_Resource video_track,
+                           PP_Resource* frame,
+                           struct PP_CompletionCallback callback);
+  /**
+   * Sends a frame returned by |GetEmptyFrame()| to the output track.
+   * After this function, the |frame| should not be used anymore and the
+   * caller should release the reference that it holds.
+   */
+  int32_t (*PutFrame)(PP_Resource video_track, PP_Resource frame);
+};
+
+struct PPB_MediaStreamVideoTrack_0_1 {
+  PP_Bool (*IsMediaStreamVideoTrack)(PP_Resource resource);
+  int32_t (*Configure)(PP_Resource video_track,
+                       const int32_t attrib_list[],
+                       struct PP_CompletionCallback callback);
+  int32_t (*GetAttrib)(PP_Resource video_track,
+                       PP_MediaStreamVideoTrack_Attrib attrib,
+                       int32_t* value);
+  struct PP_Var (*GetId)(PP_Resource video_track);
+  PP_Bool (*HasEnded)(PP_Resource video_track);
+  int32_t (*GetFrame)(PP_Resource video_track,
+                      PP_Resource* frame,
+                      struct PP_CompletionCallback callback);
+  int32_t (*RecycleFrame)(PP_Resource video_track, PP_Resource frame);
+  void (*Close)(PP_Resource video_track);
 };
 
 typedef struct PPB_MediaStreamVideoTrack_0_1 PPB_MediaStreamVideoTrack;
diff --git a/ppapi/cpp/media_stream_video_track.cc b/ppapi/cpp/media_stream_video_track.cc
index 38065a3..47ff140 100644
--- a/ppapi/cpp/media_stream_video_track.cc
+++ b/ppapi/cpp/media_stream_video_track.cc
@@ -15,6 +15,10 @@ namespace pp {
 
 namespace {
 
+template <> const char* interface_name<PPB_MediaStreamVideoTrack_1_0>() {
+  return PPB_MEDIASTREAMVIDEOTRACK_INTERFACE_1_0;
+}
+
 template <> const char* interface_name<PPB_MediaStreamVideoTrack_0_1>() {
   return PPB_MEDIASTREAMVIDEOTRACK_INTERFACE_0_1;
 }
@@ -33,6 +37,16 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(const Resource& resource)
   PP_DCHECK(IsMediaStreamVideoTrack(resource));
 }
 
+MediaStreamVideoTrack::MediaStreamVideoTrack(const InstanceHandle& instance) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    PassRefFromConstructor(
+        get_interface<PPB_MediaStreamVideoTrack_1_0>()->Create(
+            instance.pp_instance()));
+    return;
+  }
+  PP_DCHECK(false);
+}
+
 MediaStreamVideoTrack::MediaStreamVideoTrack(PassRef, PP_Resource resource)
     : Resource(PASS_REF, resource) {
 }
@@ -43,7 +57,10 @@ MediaStreamVideoTrack::~MediaStreamVideoTrack() {
 int32_t MediaStreamVideoTrack::Configure(
     const int32_t attributes[],
     const CompletionCallback& callback) {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return get_interface<PPB_MediaStreamVideoTrack_1_0>()->Configure(
+        pp_resource(), attributes, callback.pp_completion_callback());
+  } else if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
     return get_interface<PPB_MediaStreamVideoTrack_0_1>()->Configure(
         pp_resource(), attributes, callback.pp_completion_callback());
   }
@@ -52,7 +69,10 @@ int32_t MediaStreamVideoTrack::Configure(
 
 int32_t MediaStreamVideoTrack::GetAttrib(PP_MediaStreamVideoTrack_Attrib attrib,
                                          int32_t* value) {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return get_interface<PPB_MediaStreamVideoTrack_1_0>()->GetAttrib(
+        pp_resource(), attrib, value);
+  } else if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
     return get_interface<PPB_MediaStreamVideoTrack_0_1>()->GetAttrib(
         pp_resource(), attrib, value);
   }
@@ -60,7 +80,12 @@ int32_t MediaStreamVideoTrack::GetAttrib(PP_MediaStreamVideoTrack_Attrib attrib,
 }
 
 std::string MediaStreamVideoTrack::GetId() const {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    pp::Var id(PASS_REF, get_interface<PPB_MediaStreamVideoTrack_1_0>()->GetId(
+        pp_resource()));
+    if (id.is_string())
+      return id.AsString();
+  } else if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
     pp::Var id(PASS_REF, get_interface<PPB_MediaStreamVideoTrack_0_1>()->GetId(
         pp_resource()));
     if (id.is_string())
@@ -70,7 +95,10 @@ std::string MediaStreamVideoTrack::GetId() const {
 }
 
 bool MediaStreamVideoTrack::HasEnded() const {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return PP_ToBool(get_interface<PPB_MediaStreamVideoTrack_1_0>()->HasEnded(
+        pp_resource()));
+  } else if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
     return PP_ToBool(get_interface<PPB_MediaStreamVideoTrack_0_1>()->HasEnded(
         pp_resource()));
   }
@@ -79,7 +107,10 @@ bool MediaStreamVideoTrack::HasEnded() const {
 
 int32_t MediaStreamVideoTrack::GetFrame(
     const CompletionCallbackWithOutput<VideoFrame>& callback) {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return get_interface<PPB_MediaStreamVideoTrack_1_0>()->GetFrame(
+        pp_resource(), callback.output(), callback.pp_completion_callback());
+  } else if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
     return get_interface<PPB_MediaStreamVideoTrack_0_1>()->GetFrame(
         pp_resource(), callback.output(), callback.pp_completion_callback());
   }
@@ -87,7 +118,10 @@ int32_t MediaStreamVideoTrack::GetFrame(
 }
 
 int32_t MediaStreamVideoTrack::RecycleFrame(const VideoFrame& frame) {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return get_interface<PPB_MediaStreamVideoTrack_1_0>()->RecycleFrame(
+        pp_resource(), frame.pp_resource());
+  } else if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
     return get_interface<PPB_MediaStreamVideoTrack_0_1>()->RecycleFrame(
         pp_resource(), frame.pp_resource());
   }
@@ -95,12 +129,35 @@ int32_t MediaStreamVideoTrack::RecycleFrame(const VideoFrame& frame) {
 }
 
 void MediaStreamVideoTrack::Close() {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>())
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>())
+    get_interface<PPB_MediaStreamVideoTrack_1_0>()->Close(pp_resource());
+  else if (has_interface<PPB_MediaStreamVideoTrack_0_1>())
     get_interface<PPB_MediaStreamVideoTrack_0_1>()->Close(pp_resource());
+
+}
+
+int32_t MediaStreamVideoTrack::GetEmptyFrame(
+    const CompletionCallbackWithOutput<VideoFrame>& callback) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return get_interface<PPB_MediaStreamVideoTrack_1_0>()->GetEmptyFrame(
+        pp_resource(), callback.output(), callback.pp_completion_callback());
+  }
+  return callback.MayForce(PP_ERROR_NOINTERFACE);
+}
+
+int32_t MediaStreamVideoTrack::PutFrame(const VideoFrame& frame) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return get_interface<PPB_MediaStreamVideoTrack_1_0>()->PutFrame(
+        pp_resource(), frame.pp_resource());
+  }
+  return PP_ERROR_NOINTERFACE;
 }
 
 bool MediaStreamVideoTrack::IsMediaStreamVideoTrack(const Resource& resource) {
-  if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
+  if (has_interface<PPB_MediaStreamVideoTrack_1_0>()) {
+    return PP_ToBool(get_interface<PPB_MediaStreamVideoTrack_1_0>()->
+        IsMediaStreamVideoTrack(resource.pp_resource()));
+  } else if (has_interface<PPB_MediaStreamVideoTrack_0_1>()) {
     return PP_ToBool(get_interface<PPB_MediaStreamVideoTrack_0_1>()->
         IsMediaStreamVideoTrack(resource.pp_resource()));
   }
diff --git a/ppapi/cpp/media_stream_video_track.h b/ppapi/cpp/media_stream_video_track.h
index 6975986..5d03745 100644
--- a/ppapi/cpp/media_stream_video_track.h
+++ b/ppapi/cpp/media_stream_video_track.h
@@ -41,6 +41,10 @@ class MediaStreamVideoTrack : public Resource {
   /// @param[in] resource A <code>PPB_MediaStreamVideoTrack</code> resource.
   explicit MediaStreamVideoTrack(const Resource& resource);
 
+  /// Constructs a <code>MediaStreamVideoTrack</code> that outputs given frames
+  /// to a new video track, which will be consumed by Javascript.
+  explicit MediaStreamVideoTrack(const InstanceHandle& instance);
+
   /// A constructor used when you have received a <code>PP_Resource</code> as a
   /// return value that has had 1 ref added for you.
   ///
@@ -134,6 +138,17 @@ class MediaStreamVideoTrack : public Resource {
   /// After calling <code>Close()</code>, no new frames will be received.
   void Close();
 
+  // Gets a free frame for output. The frame is allocated by
+  // <code>Configure()</code>. The caller should fill it with frame data, and
+  // then use |PutFrame()| to send the frame back.
+  int32_t GetEmptyFrame(
+      const CompletionCallbackWithOutput<VideoFrame>& callback);
+
+  // Sends a frame returned by |GetEmptyFrame()| to the output track.
+  // After this function, the |frame| should not be used anymore and the
+  // caller should release the reference that it holds.
+  int32_t PutFrame(const VideoFrame& frame);
+
   /// Checks whether a <code>Resource</code> is a MediaStream video track,
   /// to test whether it is appropriate for use with the
   /// <code>MediaStreamVideoTrack</code> constructor.
diff --git a/ppapi/host/resource_host.cc b/ppapi/host/resource_host.cc
index 4e12260..b453398 100644
--- a/ppapi/host/resource_host.cc
+++ b/ppapi/host/resource_host.cc
@@ -56,6 +56,10 @@ bool ResourceHost::IsFileSystemHost() {
   return false;
 }
 
+bool ResourceHost::IsMediaStreamVideoTrackHost() {
+  return false;
+}
+
 bool ResourceHost::IsGraphics2DHost() {
   return false;
 }
diff --git a/ppapi/host/resource_host.h b/ppapi/host/resource_host.h
index 37ccbed..a9518ee 100644
--- a/ppapi/host/resource_host.h
+++ b/ppapi/host/resource_host.h
@@ -59,6 +59,7 @@ class PPAPI_HOST_EXPORT ResourceHost : public ResourceMessageHandler {
   virtual bool IsFileRefHost();
   virtual bool IsFileSystemHost();
   virtual bool IsGraphics2DHost();
+  virtual bool IsMediaStreamVideoTrackHost();
 
  protected:
   // Adds a ResourceMessageFilter to handle resource messages. Incoming
diff --git a/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c b/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
index 4713148..a94e0df 100644
--- a/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
+++ b/ppapi/native_client/src/untrusted/pnacl_irt_shim/pnacl_shim.c
@@ -115,6 +115,7 @@ static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_TouchInputEvent_1_0;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_IMEInputEvent_1_0;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MediaStreamAudioTrack_0_1;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_0_1;
+static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MessageLoop_1_0;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_Messaging_1_0;
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MouseLock_1_0;
@@ -1075,6 +1076,65 @@ static void Pnacl_M35_PPB_MediaStreamVideoTrack_Close(PP_Resource video_track) {
 
 /* End wrapper methods for PPB_MediaStreamVideoTrack_0_1 */
 
+/* Begin wrapper methods for PPB_MediaStreamVideoTrack_1_0 */
+
+static PP_Resource Pnacl_M36_PPB_MediaStreamVideoTrack_Create(PP_Instance instance) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->Create(instance);
+}
+
+static PP_Bool Pnacl_M36_PPB_MediaStreamVideoTrack_IsMediaStreamVideoTrack(PP_Resource resource) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->IsMediaStreamVideoTrack(resource);
+}
+
+static int32_t Pnacl_M36_PPB_MediaStreamVideoTrack_Configure(PP_Resource video_track, const int32_t attrib_list[], struct PP_CompletionCallback* callback) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->Configure(video_track, attrib_list, *callback);
+}
+
+static int32_t Pnacl_M36_PPB_MediaStreamVideoTrack_GetAttrib(PP_Resource video_track, PP_MediaStreamVideoTrack_Attrib attrib, int32_t* value) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->GetAttrib(video_track, attrib, value);
+}
+
+static void Pnacl_M36_PPB_MediaStreamVideoTrack_GetId(struct PP_Var* _struct_result, PP_Resource video_track) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  *_struct_result = iface->GetId(video_track);
+}
+
+static PP_Bool Pnacl_M36_PPB_MediaStreamVideoTrack_HasEnded(PP_Resource video_track) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->HasEnded(video_track);
+}
+
+static int32_t Pnacl_M36_PPB_MediaStreamVideoTrack_GetFrame(PP_Resource video_track, PP_Resource* frame, struct PP_CompletionCallback* callback) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->GetFrame(video_track, frame, *callback);
+}
+
+static int32_t Pnacl_M36_PPB_MediaStreamVideoTrack_RecycleFrame(PP_Resource video_track, PP_Resource frame) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->RecycleFrame(video_track, frame);
+}
+
+static void Pnacl_M36_PPB_MediaStreamVideoTrack_Close(PP_Resource video_track) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  iface->Close(video_track);
+}
+
+static int32_t Pnacl_M36_PPB_MediaStreamVideoTrack_GetEmptyFrame(PP_Resource video_track, PP_Resource* frame, struct PP_CompletionCallback* callback) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->GetEmptyFrame(video_track, frame, *callback);
+}
+
+static int32_t Pnacl_M36_PPB_MediaStreamVideoTrack_PutFrame(PP_Resource video_track, PP_Resource frame) {
+  const struct PPB_MediaStreamVideoTrack_1_0 *iface = Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0.real_iface;
+  return iface->PutFrame(video_track, frame);
+}
+
+/* End wrapper methods for PPB_MediaStreamVideoTrack_1_0 */
+
 /* Begin wrapper methods for PPB_MessageLoop_1_0 */
 
 static PP_Resource Pnacl_M25_PPB_MessageLoop_Create(PP_Instance instance) {
@@ -4375,6 +4435,20 @@ static const struct PPB_MediaStreamVideoTrack_0_1 Pnacl_Wrappers_PPB_MediaStream
     .Close = (void (*)(PP_Resource video_track))&Pnacl_M35_PPB_MediaStreamVideoTrack_Close
 };
 
+static const struct PPB_MediaStreamVideoTrack_1_0 Pnacl_Wrappers_PPB_MediaStreamVideoTrack_1_0 = {
+    .Create = (PP_Resource (*)(PP_Instance instance))&Pnacl_M36_PPB_MediaStreamVideoTrack_Create,
+    .IsMediaStreamVideoTrack = (PP_Bool (*)(PP_Resource resource))&Pnacl_M36_PPB_MediaStreamVideoTrack_IsMediaStreamVideoTrack,
+    .Configure = (int32_t (*)(PP_Resource video_track, const int32_t attrib_list[], struct PP_CompletionCallback callback))&Pnacl_M36_PPB_MediaStreamVideoTrack_Configure,
+    .GetAttrib = (int32_t (*)(PP_Resource video_track, PP_MediaStreamVideoTrack_Attrib attrib, int32_t* value))&Pnacl_M36_PPB_MediaStreamVideoTrack_GetAttrib,
+    .GetId = (struct PP_Var (*)(PP_Resource video_track))&Pnacl_M36_PPB_MediaStreamVideoTrack_GetId,
+    .HasEnded = (PP_Bool (*)(PP_Resource video_track))&Pnacl_M36_PPB_MediaStreamVideoTrack_HasEnded,
+    .GetFrame = (int32_t (*)(PP_Resource video_track, PP_Resource* frame, struct PP_CompletionCallback callback))&Pnacl_M36_PPB_MediaStreamVideoTrack_GetFrame,
+    .RecycleFrame = (int32_t (*)(PP_Resource video_track, PP_Resource frame))&Pnacl_M36_PPB_MediaStreamVideoTrack_RecycleFrame,
+    .Close = (void (*)(PP_Resource video_track))&Pnacl_M36_PPB_MediaStreamVideoTrack_Close,
+    .GetEmptyFrame = (int32_t (*)(PP_Resource video_track, PP_Resource* frame, struct PP_CompletionCallback callback))&Pnacl_M36_PPB_MediaStreamVideoTrack_GetEmptyFrame,
+    .PutFrame = (int32_t (*)(PP_Resource video_track, PP_Resource frame))&Pnacl_M36_PPB_MediaStreamVideoTrack_PutFrame
+};
+
 static const struct PPB_MessageLoop_1_0 Pnacl_Wrappers_PPB_MessageLoop_1_0 = {
     .Create = (PP_Resource (*)(PP_Instance instance))&Pnacl_M25_PPB_MessageLoop_Create,
     .GetForMainThread = (PP_Resource (*)(void))&Pnacl_M25_PPB_MessageLoop_GetForMainThread,
@@ -5367,6 +5441,12 @@ static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_0_1
   .real_iface = NULL
 };
 
+static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0 = {
+  .iface_macro = PPB_MEDIASTREAMVIDEOTRACK_INTERFACE_1_0,
+  .wrapped_iface = (const void *) &Pnacl_Wrappers_PPB_MediaStreamVideoTrack_1_0,
+  .real_iface = NULL
+};
+
 static struct __PnaclWrapperInfo Pnacl_WrapperInfo_PPB_MessageLoop_1_0 = {
   .iface_macro = PPB_MESSAGELOOP_INTERFACE_1_0,
   .wrapped_iface = (const void *) &Pnacl_Wrappers_PPB_MessageLoop_1_0,
@@ -5870,6 +5950,7 @@ static struct __PnaclWrapperInfo *s_ppb_wrappers[] = {
   &Pnacl_WrapperInfo_PPB_IMEInputEvent_1_0,
   &Pnacl_WrapperInfo_PPB_MediaStreamAudioTrack_0_1,
   &Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_0_1,
+  &Pnacl_WrapperInfo_PPB_MediaStreamVideoTrack_1_0,
   &Pnacl_WrapperInfo_PPB_MessageLoop_1_0,
   &Pnacl_WrapperInfo_PPB_Messaging_1_0,
   &Pnacl_WrapperInfo_PPB_MouseLock_1_0,
diff --git a/ppapi/proxy/media_stream_track_resource_base.cc b/ppapi/proxy/media_stream_track_resource_base.cc
index d259036..4431da3 100644
--- a/ppapi/proxy/media_stream_track_resource_base.cc
+++ b/ppapi/proxy/media_stream_track_resource_base.cc
@@ -22,6 +22,14 @@ MediaStreamTrackResourceBase::MediaStreamTrackResourceBase(
   AttachToPendingHost(RENDERER, pending_renderer_id);
 }
 
+MediaStreamTrackResourceBase::MediaStreamTrackResourceBase(
+    Connection connection,
+    PP_Instance instance)
+    : PluginResource(connection, instance),
+      buffer_manager_(this),
+      has_ended_(false) {
+}
+
 MediaStreamTrackResourceBase::~MediaStreamTrackResourceBase() {
 }
 
@@ -40,6 +48,9 @@ void MediaStreamTrackResourceBase::OnReplyReceived(
         PpapiPluginMsg_MediaStreamTrack_InitBuffers, OnPluginMsgInitBuffers)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
         PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer, OnPluginMsgEnqueueBuffer)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_MediaStreamTrack_EnqueueBuffers,
+        OnPluginMsgEnqueueBuffers)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
         PluginResource::OnReplyReceived(params, msg))
   IPC_END_MESSAGE_MAP()
@@ -55,11 +66,13 @@ void MediaStreamTrackResourceBase::CloseInternal() {
 void MediaStreamTrackResourceBase::OnPluginMsgInitBuffers(
     const ResourceMessageReplyParams& params,
     int32_t number_of_buffers,
-    int32_t buffer_size) {
+    int32_t buffer_size,
+    bool readonly) {
   base::SharedMemoryHandle shm_handle = base::SharedMemory::NULLHandle();
   params.TakeSharedMemoryHandleAtIndex(0, &shm_handle);
   buffer_manager_.SetBuffers(number_of_buffers, buffer_size,
-      scoped_ptr<base::SharedMemory>(new base::SharedMemory(shm_handle, true)),
+      scoped_ptr<base::SharedMemory>(new base::SharedMemory(shm_handle,
+                                                            readonly)),
       false);
 }
 
@@ -69,5 +82,12 @@ void MediaStreamTrackResourceBase::OnPluginMsgEnqueueBuffer(
   buffer_manager_.EnqueueBuffer(index);
 }
 
+void MediaStreamTrackResourceBase::OnPluginMsgEnqueueBuffers(
+    const ResourceMessageReplyParams& params,
+    const std::vector<int32_t>& indices) {
+  for (size_t i = 0; i < indices.size(); ++i)
+    buffer_manager_.EnqueueBuffer(indices[i]);
+}
+
 }  // namespace proxy
 }  // namespace ppapi
diff --git a/ppapi/proxy/media_stream_track_resource_base.h b/ppapi/proxy/media_stream_track_resource_base.h
index b5438ce..087d4a95 100644
--- a/ppapi/proxy/media_stream_track_resource_base.h
+++ b/ppapi/proxy/media_stream_track_resource_base.h
@@ -21,10 +21,14 @@ class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase
                                int pending_renderer_id,
                                const std::string& id);
 
+  MediaStreamTrackResourceBase(Connection connection, PP_Instance instance);
+
   virtual ~MediaStreamTrackResourceBase();
 
   std::string id() const { return id_; }
 
+  void set_id(const std::string& id) { id_ = id; }
+
   bool has_ended() const { return has_ended_; }
 
   MediaStreamBufferManager* buffer_manager() { return &buffer_manager_; }
@@ -45,9 +49,12 @@ class PPAPI_PROXY_EXPORT MediaStreamTrackResourceBase
   // Message handlers:
   void OnPluginMsgInitBuffers(const ResourceMessageReplyParams& params,
                               int32_t number_of_buffers,
-                              int32_t buffer_size);
+                              int32_t buffer_size,
+                              bool readonly);
   void OnPluginMsgEnqueueBuffer(const ResourceMessageReplyParams& params,
                                 int32_t index);
+  void OnPluginMsgEnqueueBuffers(const ResourceMessageReplyParams& params,
+                                 const std::vector<int32_t>& indices);
 
   MediaStreamBufferManager buffer_manager_;
 
diff --git a/ppapi/proxy/media_stream_video_track_resource.cc b/ppapi/proxy/media_stream_video_track_resource.cc
index aaa5b52..fc602311 100644
--- a/ppapi/proxy/media_stream_video_track_resource.cc
+++ b/ppapi/proxy/media_stream_video_track_resource.cc
@@ -24,6 +24,14 @@ MediaStreamVideoTrackResource::MediaStreamVideoTrackResource(
       get_frame_output_(NULL) {
 }
 
+MediaStreamVideoTrackResource::MediaStreamVideoTrackResource(
+    Connection connection,
+    PP_Instance instance)
+    : MediaStreamTrackResourceBase(connection, instance),
+      get_frame_output_(NULL) {
+  SendCreate(RENDERER, PpapiHostMsg_MediaStreamVideoTrack_Create());
+}
+
 MediaStreamVideoTrackResource::~MediaStreamVideoTrackResource() {
   Close();
 }
@@ -150,6 +158,17 @@ void MediaStreamVideoTrackResource::Close() {
   MediaStreamTrackResourceBase::CloseInternal();
 }
 
+int32_t MediaStreamVideoTrackResource::GetEmptyFrame(
+    PP_Resource* frame, scoped_refptr<TrackedCallback> callback) {
+  return GetFrame(frame, callback);
+}
+
+int32_t MediaStreamVideoTrackResource::PutFrame(PP_Resource frame) {
+  // TODO(ronghuawu): Consider to rename RecycleFrame to PutFrame and use
+  // one set of GetFrame and PutFrame for both input and output.
+  return RecycleFrame(frame);
+}
+
 void MediaStreamVideoTrackResource::OnNewBufferEnqueued() {
   if (!TrackedCallback::IsPending(get_frame_callback_))
     return;
@@ -189,7 +208,13 @@ void MediaStreamVideoTrackResource::ReleaseFrames() {
 }
 
 void MediaStreamVideoTrackResource::OnPluginMsgConfigureReply(
-    const ResourceMessageReplyParams& params) {
+    const ResourceMessageReplyParams& params,
+    const std::string& track_id) {
+  if (id().empty()) {
+    set_id(track_id);
+  } else {
+    DCHECK_EQ(id(), track_id);
+  }
   if (TrackedCallback::IsPending(configure_callback_)) {
     scoped_refptr<TrackedCallback> callback;
     callback.swap(configure_callback_);
diff --git a/ppapi/proxy/media_stream_video_track_resource.h b/ppapi/proxy/media_stream_video_track_resource.h
index d1b3bb5..1e9927f 100644
--- a/ppapi/proxy/media_stream_video_track_resource.h
+++ b/ppapi/proxy/media_stream_video_track_resource.h
@@ -26,6 +26,8 @@ class PPAPI_PROXY_EXPORT MediaStreamVideoTrackResource
                                 int pending_renderer_id,
                                 const std::string& id);
 
+  MediaStreamVideoTrackResource(Connection connection, PP_Instance instance);
+
   virtual ~MediaStreamVideoTrackResource();
 
   // Resource overrides:
@@ -43,6 +45,9 @@ class PPAPI_PROXY_EXPORT MediaStreamVideoTrackResource
                            scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t RecycleFrame(PP_Resource frame) OVERRIDE;
   virtual void Close() OVERRIDE;
+  virtual int32_t GetEmptyFrame(
+      PP_Resource* frame, scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t PutFrame(PP_Resource frame) OVERRIDE;
 
   // MediaStreamBufferManager::Delegate overrides:
   virtual void OnNewBufferEnqueued() OVERRIDE;
@@ -53,7 +58,8 @@ class PPAPI_PROXY_EXPORT MediaStreamVideoTrackResource
   void ReleaseFrames();
 
   // IPC message handlers.
-  void OnPluginMsgConfigureReply(const ResourceMessageReplyParams& params);
+  void OnPluginMsgConfigureReply(const ResourceMessageReplyParams& params,
+                                 const std::string& track_id);
 
   // Allocated frame resources by |GetFrame()|.
   typedef std::map<PP_Resource, scoped_refptr<VideoFrameResource> > FrameMap;
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index 5fe5e968..95ac3d9 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -1438,20 +1438,25 @@ IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamAudioTrack_CreateFromPendingHost,
                      std::string /* track_id */)
 IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamVideoTrack_CreateFromPendingHost,
                      std::string /* track_id */)
+IPC_MESSAGE_CONTROL0(PpapiHostMsg_MediaStreamVideoTrack_Create)
 IPC_MESSAGE_CONTROL1(
     PpapiHostMsg_MediaStreamVideoTrack_Configure,
     ppapi::MediaStreamVideoTrackShared::Attributes /* attributes */)
-IPC_MESSAGE_CONTROL0(PpapiPluginMsg_MediaStreamVideoTrack_ConfigureReply)
+IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamVideoTrack_ConfigureReply,
+                     std::string /* track_id */)
 
 // Message for init buffers. It also takes a shared memory handle which is put
 // in the outer ResourceReplyMessage.
-IPC_MESSAGE_CONTROL2(PpapiPluginMsg_MediaStreamTrack_InitBuffers,
+IPC_MESSAGE_CONTROL3(PpapiPluginMsg_MediaStreamTrack_InitBuffers,
                      int32_t /* number_of_buffers */,
-                     int32_t /* buffer_size */)
+                     int32_t /* buffer_size */,
+                     bool /* readonly */)
 IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamTrack_EnqueueBuffer,
                      int32_t /* index */);
 IPC_MESSAGE_CONTROL1(PpapiHostMsg_MediaStreamTrack_EnqueueBuffer,
                      int32_t /* index */);
+IPC_MESSAGE_CONTROL1(PpapiPluginMsg_MediaStreamTrack_EnqueueBuffers,
+                     std::vector<int32_t> /* indices */);
 IPC_MESSAGE_CONTROL0(PpapiHostMsg_MediaStreamTrack_Close)
 
 // NetworkMonitor.
diff --git a/ppapi/proxy/resource_creation_proxy.cc b/ppapi/proxy/resource_creation_proxy.cc
index a4dbeec..0289e99 100644
--- a/ppapi/proxy/resource_creation_proxy.cc
+++ b/ppapi/proxy/resource_creation_proxy.cc
@@ -18,6 +18,7 @@
 #include "ppapi/proxy/graphics_2d_resource.h"
 #include "ppapi/proxy/host_resolver_private_resource.h"
 #include "ppapi/proxy/host_resolver_resource.h"
+#include "ppapi/proxy/media_stream_video_track_resource.h"
 #include "ppapi/proxy/net_address_resource.h"
 #include "ppapi/proxy/network_monitor_resource.h"
 #include "ppapi/proxy/output_protection_resource.h"
@@ -290,6 +291,12 @@ PP_Resource ResourceCreationProxy::CreateImageDataSimple(
       format, *size, init_to_zero);
 }
 
+PP_Resource ResourceCreationProxy::CreateMediaStreamVideoTrack(
+    PP_Instance instance) {
+  return (new MediaStreamVideoTrackResource(GetConnection(),
+                                            instance))->GetReference();
+}
+
 PP_Resource ResourceCreationProxy::CreateNetAddressFromIPv4Address(
     PP_Instance instance,
     const PP_NetAddress_IPv4* ipv4_addr) {
diff --git a/ppapi/proxy/resource_creation_proxy.h b/ppapi/proxy/resource_creation_proxy.h
index 4719c4a..49314fd 100644
--- a/ppapi/proxy/resource_creation_proxy.h
+++ b/ppapi/proxy/resource_creation_proxy.h
@@ -129,6 +129,8 @@ class ResourceCreationProxy : public InterfaceProxy,
                                             PP_ImageDataFormat format,
                                             const PP_Size* size,
                                             PP_Bool init_to_zero) OVERRIDE;
+  virtual PP_Resource CreateMediaStreamVideoTrack(
+      PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateNetAddressFromIPv4Address(
       PP_Instance instance,
       const PP_NetAddress_IPv4* ipv4_addr) OVERRIDE;
diff --git a/ppapi/shared_impl/media_stream_buffer_manager.cc b/ppapi/shared_impl/media_stream_buffer_manager.cc
index d6c4b0d..29bc153 100644
--- a/ppapi/shared_impl/media_stream_buffer_manager.cc
+++ b/ppapi/shared_impl/media_stream_buffer_manager.cc
@@ -59,6 +59,12 @@ int32_t MediaStreamBufferManager::DequeueBuffer() {
   return buffer;
 }
 
+std::vector<int32_t> MediaStreamBufferManager::DequeueBuffers() {
+  std::vector<int32_t> buffers(buffer_queue_.begin(), buffer_queue_.end());
+  buffer_queue_.clear();
+  return buffers;
+}
+
 void MediaStreamBufferManager::EnqueueBuffer(int32_t index) {
   CHECK_GE(index, 0) << "Invalid buffer index";
   CHECK_LT(index, number_of_buffers_) << "Invalid buffer index";
@@ -66,10 +72,9 @@ void MediaStreamBufferManager::EnqueueBuffer(int32_t index) {
   delegate_->OnNewBufferEnqueued();
 }
 
-MediaStreamBuffer* MediaStreamBufferManager::GetBufferPointer(
-    int32_t index) {
-  CHECK_GE(index, 0) << "Invalid buffer index";
-  CHECK_LT(index, number_of_buffers_) << "Invalid buffer index";
+MediaStreamBuffer* MediaStreamBufferManager::GetBufferPointer(int32_t index) {
+  if (index < 0 || index >= number_of_buffers_)
+    return NULL;
   return buffers_[index];
 }
 
diff --git a/ppapi/shared_impl/media_stream_buffer_manager.h b/ppapi/shared_impl/media_stream_buffer_manager.h
index 240be5d..eafd10c 100644
--- a/ppapi/shared_impl/media_stream_buffer_manager.h
+++ b/ppapi/shared_impl/media_stream_buffer_manager.h
@@ -62,6 +62,9 @@ class PPAPI_SHARED_EXPORT MediaStreamBufferManager {
   // Dequeues a buffer from |buffer_queue_|.
   int32_t DequeueBuffer();
 
+  // Dequeues all the buffers from |buffer_queue_|.
+  std::vector<int32_t> DequeueBuffers();
+
   // Puts a buffer into |buffer_queue_|.
   void EnqueueBuffer(int32_t index);
 
diff --git a/ppapi/shared_impl/media_stream_buffer_manager_unittest.cc b/ppapi/shared_impl/media_stream_buffer_manager_unittest.cc
index 8370567..9374875 100644
--- a/ppapi/shared_impl/media_stream_buffer_manager_unittest.cc
+++ b/ppapi/shared_impl/media_stream_buffer_manager_unittest.cc
@@ -79,11 +79,9 @@ TEST(MediaStreamBufferManager, General) {
     EXPECT_EQ(PP_ERROR_FAILED, manager.DequeueBuffer());
     EXPECT_EQ(PP_ERROR_FAILED, manager.DequeueBuffer());
 
-    // Test crash for passing invalid index to GetBufferPointer()
-    EXPECT_DEATH(manager.GetBufferPointer(-1),
-                 ".*Check failed: index >= 0.*");
-    EXPECT_DEATH(manager.GetBufferPointer(kNumberOfBuffers),
-                 ".*Check failed: index < number_of_buffers_.*");
+    // Returns NULL for invalid index to GetBufferPointer()
+    EXPECT_EQ(NULL, manager.GetBufferPointer(-1));
+    EXPECT_EQ(NULL, manager.GetBufferPointer(kNumberOfBuffers));
 
     // Test crash for passing invalid index to EnqueueBuffer().
     EXPECT_DEATH(manager.EnqueueBuffer(-1),
diff --git a/ppapi/thunk/ppb_media_stream_video_track_api.h b/ppapi/thunk/ppb_media_stream_video_track_api.h
index 9f18eaf..6cee06a 100644
--- a/ppapi/thunk/ppb_media_stream_video_track_api.h
+++ b/ppapi/thunk/ppb_media_stream_video_track_api.h
@@ -23,6 +23,10 @@ class PPAPI_THUNK_EXPORT PPB_MediaStreamVideoTrack_API {
                            scoped_refptr<ppapi::TrackedCallback> callback) = 0;
   virtual int32_t RecycleFrame(PP_Resource frame) = 0;
   virtual void Close() = 0;
+  virtual int32_t GetEmptyFrame(
+      PP_Resource* frame,
+      scoped_refptr<ppapi::TrackedCallback> callback) = 0;
+  virtual int32_t PutFrame(PP_Resource frame) = 0;
 };
 
 }  // namespace thunk
diff --git a/ppapi/thunk/ppb_media_stream_video_track_thunk.cc b/ppapi/thunk/ppb_media_stream_video_track_thunk.cc
index c39ee1c..8a26a41 100644
--- a/ppapi/thunk/ppb_media_stream_video_track_thunk.cc
+++ b/ppapi/thunk/ppb_media_stream_video_track_thunk.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// From ppb_media_stream_video_track.idl modified Tue Mar 25 18:18:10 2014.
+// From ppb_media_stream_video_track.idl modified Mon Mar 31 14:40:45 2014.
 
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
@@ -17,6 +17,14 @@ namespace thunk {
 
 namespace {
 
+PP_Resource Create(PP_Instance instance) {
+  VLOG(4) << "PPB_MediaStreamVideoTrack::Create()";
+  EnterResourceCreation enter(instance);
+  if (enter.failed())
+    return 0;
+  return enter.functions()->CreateMediaStreamVideoTrack(instance);
+}
+
 PP_Bool IsMediaStreamVideoTrack(PP_Resource resource) {
   VLOG(4) << "PPB_MediaStreamVideoTrack::IsMediaStreamVideoTrack()";
   EnterResource<PPB_MediaStreamVideoTrack_API> enter(resource, false);
@@ -90,6 +98,27 @@ void Close(PP_Resource video_track) {
   enter.object()->Close();
 }
 
+int32_t GetEmptyFrame(PP_Resource video_track,
+                      PP_Resource* frame,
+                      struct PP_CompletionCallback callback) {
+  VLOG(4) << "PPB_MediaStreamVideoTrack::GetEmptyFrame()";
+  EnterResource<PPB_MediaStreamVideoTrack_API> enter(video_track,
+                                                     callback,
+                                                     true);
+  if (enter.failed())
+    return enter.retval();
+  return enter.SetResult(enter.object()->GetEmptyFrame(frame,
+                                                       enter.callback()));
+}
+
+int32_t PutFrame(PP_Resource video_track, PP_Resource frame) {
+  VLOG(4) << "PPB_MediaStreamVideoTrack::PutFrame()";
+  EnterResource<PPB_MediaStreamVideoTrack_API> enter(video_track, true);
+  if (enter.failed())
+    return enter.retval();
+  return enter.object()->PutFrame(frame);
+}
+
 const PPB_MediaStreamVideoTrack_0_1 g_ppb_mediastreamvideotrack_thunk_0_1 = {
   &IsMediaStreamVideoTrack,
   &Configure,
@@ -101,6 +130,20 @@ const PPB_MediaStreamVideoTrack_0_1 g_ppb_mediastreamvideotrack_thunk_0_1 = {
   &Close
 };
 
+const PPB_MediaStreamVideoTrack_1_0 g_ppb_mediastreamvideotrack_thunk_1_0 = {
+  &Create,
+  &IsMediaStreamVideoTrack,
+  &Configure,
+  &GetAttrib,
+  &GetId,
+  &HasEnded,
+  &GetFrame,
+  &RecycleFrame,
+  &Close,
+  &GetEmptyFrame,
+  &PutFrame
+};
+
 }  // namespace
 
 PPAPI_THUNK_EXPORT const PPB_MediaStreamVideoTrack_0_1*
@@ -108,5 +151,10 @@ PPAPI_THUNK_EXPORT const PPB_MediaStreamVideoTrack_0_1*
   return &g_ppb_mediastreamvideotrack_thunk_0_1;
 }
 
+PPAPI_THUNK_EXPORT const PPB_MediaStreamVideoTrack_1_0*
+    GetPPB_MediaStreamVideoTrack_1_0_Thunk() {
+  return &g_ppb_mediastreamvideotrack_thunk_1_0;
+}
+
 }  // namespace thunk
 }  // namespace ppapi
diff --git a/ppapi/thunk/resource_creation_api.h b/ppapi/thunk/resource_creation_api.h
index 0c3dd42..f06b7d4 100644
--- a/ppapi/thunk/resource_creation_api.h
+++ b/ppapi/thunk/resource_creation_api.h
@@ -141,6 +141,7 @@ class ResourceCreationAPI {
                                             PP_ImageDataFormat format,
                                             const PP_Size* size,
                                             PP_Bool init_to_zero) = 0;
+  virtual PP_Resource CreateMediaStreamVideoTrack(PP_Instance instance) = 0;
   virtual PP_Resource CreateNetAddressFromIPv4Address(
       PP_Instance instance,
       const PP_NetAddress_IPv4* ipv4_addr) = 0;