Update Android IPC messages to EME WD

content/renderer/media/android/proxy_media_keys.cc

 // Copyright 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.
 
 #include "content/renderer/media/android/proxy_media_keys.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 31 matching lines @@
   std::vector<uint8> uuid = GetUUID(key_system);
   DCHECK(!uuid.empty());
   manager_->InitializeCDM(media_keys_id_, this, uuid, frame_url);
 #endif
 }
 
 bool ProxyMediaKeys::CreateSession(uint32 reference_id,
                                    const std::string& type,
                                    const uint8* init_data,
                                    int init_data_length) {
-  manager_->GenerateKeyRequest(
+  manager_->CreateSession(
       media_keys_id_,
       reference_id,
       type,
       std::vector<uint8>(init_data, init_data + init_data_length));
   return true;
 }
 
 void ProxyMediaKeys::UpdateSession(uint32 reference_id,
                                    const uint8* response,
                                    int response_length) {
-  manager_->AddKey(media_keys_id_,
-                   reference_id,
-                   std::vector<uint8>(response, response + response_length),
-                   std::vector<uint8>());
+  manager_->UpdateSession(
+      media_keys_id_,
+      reference_id,
+      std::vector<uint8>(response, response + response_length));
 }
 
 void ProxyMediaKeys::ReleaseSession(uint32 reference_id) {
-  manager_->CancelKeyRequest(media_keys_id_, reference_id);
+  manager_->ReleaseSession(media_keys_id_, reference_id);
 }
 
 void ProxyMediaKeys::OnSessionCreated(uint32 reference_id,
-                                      const std::string& session_id) {
-  session_created_cb_.Run(reference_id, session_id);
+                                      const std::string& web_session_id) {
+  session_created_cb_.Run(reference_id, web_session_id);
 }
 
 void ProxyMediaKeys::OnSessionMessage(uint32 reference_id,
                                       const std::vector<uint8>& message,
                                       const std::string& destination_url) {
   session_message_cb_.Run(reference_id, message, destination_url);
 }
 
 void ProxyMediaKeys::OnSessionReady(uint32 reference_id) {
   session_ready_cb_.Run(reference_id);
 }
 
 void ProxyMediaKeys::OnSessionClosed(uint32 reference_id) {
   session_closed_cb_.Run(reference_id);
 }
 
 void ProxyMediaKeys::OnSessionError(uint32 reference_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   session_error_cb_.Run(reference_id, error_code, system_code);
 }
 
 }  // namespace content