Update Pepper interface for EME

ppapi/proxy/ppb_instance_proxy.cc

Index: ppapi/proxy/ppb_instance_proxy.cc
diff --git a/ppapi/proxy/ppb_instance_proxy.cc b/ppapi/proxy/ppb_instance_proxy.cc
index 2780022d605b2e13f7efa82dbb956e71ff575379..e93a21900ef5eacda01d61841b48f970d035fb7e 100644
--- a/ppapi/proxy/ppb_instance_proxy.cc
+++ b/ppapi/proxy/ppb_instance_proxy.cc
@@ -6,6 +6,7 @@
 
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
+#include "media/base/limits.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/c/pp_var.h"
@@ -34,9 +35,11 @@
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/proxy/truetype_font_singleton_resource.h"
 #include "ppapi/proxy/uma_private_resource.h"
+#include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
+#include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_compositor_api.h"
@@ -179,10 +182,16 @@ bool PPB_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
                         OnHostMsgPromiseResolved)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolvedWithSession,
                         OnHostMsgPromiseResolvedWithSession)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseResolvedWithKeyIds,
+                        OnHostMsgPromiseResolvedWithKeyIds)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PromiseRejected,
                         OnHostMsgPromiseRejected)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionMessage,
                         OnHostMsgSessionMessage)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionKeysChange,
+                        OnHostMsgSessionKeysChange)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionExpirationChange,
+                        OnHostMsgSessionExpirationChange)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionReady,
                         OnHostMsgSessionReady)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SessionClosed,
@@ -577,6 +586,35 @@ void PPB_Instance_Proxy::PromiseResolvedWithSession(PP_Instance instance,
       SerializedVarSendInput(dispatcher(), web_session_id_var)));
 }
 
+void PPB_Instance_Proxy::PromiseResolvedWithKeyIds(PP_Instance instance,
+                                                   uint32 promise_id,
+                                                   PP_Var key_ids_var) {
+  ArrayVar* key_ids_array = ArrayVar::FromPPVar(key_ids_var);
+  if (!key_ids_array ||
+      key_ids_array->GetLength() > media::limits::kMaxKeyIds) {
+    NOTREACHED();
+    return;
+  }
+
+  std::vector<std::vector<uint8_t> > key_ids;
+  for (size_t i = 0; i < key_ids_array->GetLength(); ++i) {
+    ArrayBufferVar* key_id = ArrayBufferVar::FromPPVar(key_ids_array->Get(i));
+    if (!key_id || key_id->ByteLength() < media::limits::kMinKeyIdLength ||
+        key_id->ByteLength() > media::limits::kMaxKeyIdLength) {
+      NOTREACHED();
+      continue;
+    }
+
+    const uint8_t* key_id_ptr = static_cast<const uint8_t*>(key_id->Map());
+    const uint32_t key_id_size = key_id->ByteLength();
+    std::vector<uint8_t> key_id_vector(key_id_ptr, key_id_ptr + key_id_size);
+    key_ids.push_back(key_id_vector);
+  }
+
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_PromiseResolvedWithKeyIds(
+      API_ID_PPB_INSTANCE, instance, promise_id, key_ids));
+}
+
 void PPB_Instance_Proxy::PromiseRejected(PP_Instance instance,
                                          uint32 promise_id,
                                          PP_CdmExceptionCode exception_code,
@@ -603,6 +641,37 @@ void PPB_Instance_Proxy::SessionMessage(PP_Instance instance,
       SerializedVarSendInput(dispatcher(), destination_url_var)));
 }
 
+void PPB_Instance_Proxy::SessionKeysChange(PP_Instance instance,
+                                           PP_Var web_session_id_var,
+                                           PP_Bool has_additional_usable_key) {
+  StringVar* session_id = StringVar::FromPPVar(web_session_id_var);
+  if (!session_id ||
+      session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionKeysChange(
+      API_ID_PPB_INSTANCE,
+      instance,
+      session_id->value(),
+      has_additional_usable_key));
+}
+
+void PPB_Instance_Proxy::SessionExpirationChange(PP_Instance instance,
+                                                 PP_Var web_session_id_var,
+                                                 PP_Time new_expiry_time) {
+  StringVar* session_id = StringVar::FromPPVar(web_session_id_var);
+  if (!session_id ||
+      session_id->value().length() > media::limits::kMaxWebSessionIdLength) {
+    NOTREACHED();
+    return;
+  }
+
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionExpirationChange(
+      API_ID_PPB_INSTANCE, instance, session_id->value(), new_expiry_time));
+}
+
 void PPB_Instance_Proxy::SessionReady(PP_Instance instance,
                                       PP_Var web_session_id_var) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_SessionReady(
@@ -1198,6 +1267,40 @@ void PPB_Instance_Proxy::OnHostMsgPromiseResolvedWithSession(
   }
 }
 
+void PPB_Instance_Proxy::OnHostMsgPromiseResolvedWithKeyIds(
+    PP_Instance instance,
+    uint32_t promise_id,
+    const std::vector<std::vector<uint8_t> >& key_ids) {
+  if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+    return;
+  if (key_ids.size() > media::limits::kMaxKeyIds) {
+    NOTREACHED();
+    return;
+  }
+
+  scoped_refptr<ArrayVar> key_ids_array = new ArrayVar();
+  key_ids_array->SetLength(key_ids.size());
+  for (size_t i = 0; i < key_ids.size(); ++i) {
+    const std::vector<uint8_t>& entry = key_ids[i];
+    if (entry.size() < media::limits::kMinKeyIdLength ||
+        entry.size() > media::limits::kMaxKeyIdLength) {
+      NOTREACHED();
+      continue;
+    }
+    key_ids_array->Set(
+        i,
+        PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(entry.size(),
+                                                                   &entry[0]));
+  }
+
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    ScopedPPVar key_ids_var(ScopedPPVar::PassRef(), key_ids_array->GetPPVar());
+    enter.functions()->PromiseResolvedWithKeyIds(
+        instance, promise_id, key_ids_var.get());
+  }
+}
+
 void PPB_Instance_Proxy::OnHostMsgPromiseRejected(
     PP_Instance instance,
     uint32_t promise_id,
@@ -1232,6 +1335,36 @@ void PPB_Instance_Proxy::OnHostMsgSessionMessage(
   }
 }
 
+void PPB_Instance_Proxy::OnHostMsgSessionKeysChange(
+    PP_Instance instance,
+    const std::string& web_session_id,
+    PP_Bool has_additional_usable_key) {
+  if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+    return;
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
+                                   StringVar::StringToPPVar(web_session_id));
+    enter.functions()->SessionKeysChange(
+        instance, web_session_id_var.get(), has_additional_usable_key);
+  }
+}
+
+void PPB_Instance_Proxy::OnHostMsgSessionExpirationChange(
+    PP_Instance instance,
+    const std::string& web_session_id,
+    PP_Time new_expiry_time) {
+  if (!dispatcher()->permissions().HasPermission(PERMISSION_PRIVATE))
+    return;
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    ScopedPPVar web_session_id_var(ScopedPPVar::PassRef(),
+                                   StringVar::StringToPPVar(web_session_id));
+    enter.functions()->SessionExpirationChange(
+        instance, web_session_id_var.get(), new_expiry_time);
+  }
+}
+
 void PPB_Instance_Proxy::OnHostMsgSessionReady(
     PP_Instance instance,
     SerializedVarReceiveInput web_session_id) {