Encrypted Media: Use std::string for key message in media pipeline.

This is part of the changes to use string for key messages. We also need to make the same change in CDM.h, CDMs and PPAPI.

TBR=dmichael@chromium.org
BUG=164498
TEST=media_unittests; EME demo works.

Review URL: https://chromiumcodereview.appspot.com/11459005

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

13 files changed, 43 insertions, 83 deletions

diff --git a/media/base/decryptor_client.h b/media/base/decryptor_client.h
index dc64419..14d09a9 100644
--- a/media/base/decryptor_client.h
+++ b/media/base/decryptor_client.h
@@ -30,8 +30,7 @@ class DecryptorClient {
   // Signals that a key message has been generated.
   virtual void KeyMessage(const std::string& key_system,
                           const std::string& session_id,
-                          scoped_array<uint8> message,
-                          int message_length,
+                          const std::string& message,
                           const std::string& default_url) = 0;
 
   // Signals that a key is needed for decryption. |key_system| and |session_id|
diff --git a/media/base/mock_filters.cc b/media/base/mock_filters.cc
index bf6beac..c197ee2 100644
--- a/media/base/mock_filters.cc
+++ b/media/base/mock_filters.cc
@@ -60,15 +60,6 @@ MockDecryptorClient::MockDecryptorClient() {}
 
 MockDecryptorClient::~MockDecryptorClient() {}
 
-void MockDecryptorClient::KeyMessage(const std::string& key_system,
-                                     const std::string& session_id,
-                                     scoped_array<uint8> message,
-                                     int message_length,
-                                     const std::string& default_url) {
-  KeyMessageMock(key_system, session_id, message.get(), message_length,
-                 default_url);
-}
-
 void MockDecryptorClient::NeedKey(const std::string& key_system,
                                   const std::string& session_id,
                                   const std::string& type,
diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index 6e8df1d..d5a27b0 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -249,25 +249,19 @@ class MockDecryptorClient : public DecryptorClient {
   MOCK_METHOD2(KeyAdded, void(const std::string&, const std::string&));
   MOCK_METHOD4(KeyError, void(const std::string&, const std::string&,
                               Decryptor::KeyError, int));
+  MOCK_METHOD4(KeyMessage, void(const std::string& key_system,
+                                const std::string& session_id,
+                                const std::string& message,
+                                const std::string& default_url));
   // TODO(xhwang): This is a workaround of the issue that move-only parameters
   // are not supported in mocked methods. Remove this when the issue is fixed
   // (http://code.google.com/p/googletest/issues/detail?id=395) or when we use
   // std::string instead of scoped_array<uint8> (http://crbug.com/130689).
-  MOCK_METHOD5(KeyMessageMock, void(const std::string& key_system,
-                                    const std::string& session_id,
-                                    const uint8* message,
-                                    int message_length,
-                                    const std::string& default_url));
   MOCK_METHOD5(NeedKeyMock, void(const std::string& key_system,
                                  const std::string& session_id,
                                  const std::string& type,
                                  const uint8* init_data,
                                  int init_data_length));
-  virtual void KeyMessage(const std::string& key_system,
-                          const std::string& session_id,
-                          scoped_array<uint8> message,
-                          int message_length,
-                          const std::string& default_url) OVERRIDE;
   virtual void NeedKey(const std::string& key_system,
                        const std::string& session_id,
                        const std::string& type,
diff --git a/media/crypto/aes_decryptor.cc b/media/crypto/aes_decryptor.cc
index a1dd46a..a4b6bc6 100644
--- a/media/crypto/aes_decryptor.cc
+++ b/media/crypto/aes_decryptor.cc
@@ -141,17 +141,13 @@ bool AesDecryptor::GenerateKeyRequest(const std::string& key_system,
 
   // For now, the AesDecryptor does not care about |key_system| and |type|;
   // just fire the event with the |init_data| as the request.
-  scoped_array<uint8> message;
-  int message_length = 0;
-
+  std::string message;
   if (init_data && init_data_length) {
-    message_length = init_data_length;
-    message.reset(new uint8[message_length]);
-    memcpy(message.get(), init_data, message_length);
+    message = std::string(reinterpret_cast<const char*>(init_data),
+                          init_data_length);
   }
 
-  client_->KeyMessage(key_system, session_id_string,
-                      message.Pass(), message_length, "");
+  client_->KeyMessage(key_system, session_id_string, message, "");
   return true;
 }
 
diff --git a/media/crypto/aes_decryptor_unittest.cc b/media/crypto/aes_decryptor_unittest.cc
index 8a35b06..2fab86d 100644
--- a/media/crypto/aes_decryptor_unittest.cc
+++ b/media/crypto/aes_decryptor_unittest.cc
@@ -20,14 +20,11 @@ using ::testing::Gt;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::SaveArg;
+using ::testing::StrEq;
 using ::testing::StrNe;
 
 namespace media {
 
-MATCHER_P2(ArrayEq, array, size, "") {
-  return !memcmp(arg, array, size);
-}
-
 // |encrypted_data| is encrypted from |plain_text| using |key|. |key_id| is
 // used to distinguish |key|.
 struct WebmEncryptedData {
@@ -239,9 +236,10 @@ class AesDecryptorTest : public testing::Test {
 
  protected:
   void GenerateKeyRequest(const uint8* key_id, int key_id_size) {
-    EXPECT_CALL(client_, KeyMessageMock(kClearKeySystem, StrNe(""),
-                                        ArrayEq(key_id, key_id_size),
-                                        key_id_size, ""))
+    std::string key_id_string(reinterpret_cast<const char*>(key_id),
+                              key_id_size);
+    EXPECT_CALL(client_, KeyMessage(kClearKeySystem,
+                                    StrNe(""), StrEq(key_id_string), ""))
         .WillOnce(SaveArg<1>(&session_id_string_));
     EXPECT_TRUE(decryptor_.GenerateKeyRequest(kClearKeySystem, "",
                                               key_id, key_id_size));
@@ -316,8 +314,7 @@ class AesDecryptorTest : public testing::Test {
 };
 
 TEST_F(AesDecryptorTest, GenerateKeyRequestWithNullInitData) {
-  EXPECT_CALL(client_, KeyMessageMock(kClearKeySystem, StrNe(""),
-                                      IsNull(), 0, ""));
+  EXPECT_CALL(client_, KeyMessage(kClearKeySystem, StrNe(""), "", ""));
   EXPECT_TRUE(decryptor_.GenerateKeyRequest(kClearKeySystem, "", NULL, 0));
 }
 
diff --git a/media/filters/pipeline_integration_test.cc b/media/filters/pipeline_integration_test.cc
index 2339402e..a9f065b 100644
--- a/media/filters/pipeline_integration_test.cc
+++ b/media/filters/pipeline_integration_test.cc
@@ -162,13 +162,11 @@ class FakeDecryptorClient : public DecryptorClient {
 
   virtual void KeyMessage(const std::string& key_system,
                           const std::string& session_id,
-                          scoped_array<uint8> message,
-                          int message_length,
+                          const std::string& message,
                           const std::string& default_url) {
     EXPECT_EQ(kClearKeySystem, key_system);
     EXPECT_FALSE(session_id.empty());
-    EXPECT_TRUE(message.get());
-    EXPECT_GT(message_length, 0);
+    EXPECT_FALSE(message.empty());
 
     current_key_system_ = key_system;
     current_session_id_ = session_id;
diff --git a/webkit/media/crypto/ppapi/clear_key_cdm.cc b/webkit/media/crypto/ppapi/clear_key_cdm.cc
index 2f0453a..88f6604 100644
--- a/webkit/media/crypto/ppapi/clear_key_cdm.cc
+++ b/webkit/media/crypto/ppapi/clear_key_cdm.cc
@@ -150,15 +150,14 @@ const char* GetCdmVersion() {
 
 namespace webkit_media {
 
-ClearKeyCdm::Client::Client() : status_(kKeyError), key_message_length_(0) {}
+ClearKeyCdm::Client::Client() : status_(kKeyError) {}
 
 ClearKeyCdm::Client::~Client() {}
 
 void ClearKeyCdm::Client::Reset() {
   status_ = kKeyError;
   session_id_.clear();
-  key_message_.reset();
-  key_message_length_ = 0;
+  key_message_.clear();
   default_url_.clear();
 }
 
@@ -178,13 +177,11 @@ void ClearKeyCdm::Client::KeyError(const std::string& key_system,
 
 void ClearKeyCdm::Client::KeyMessage(const std::string& key_system,
                                      const std::string& session_id,
-                                     scoped_array<uint8> message,
-                                     int message_length,
+                                     const std::string& message,
                                      const std::string& default_url) {
   status_ = kKeyMessage;
   session_id_ = session_id;
-  key_message_ = message.Pass();
-  key_message_length_ = message_length;
+  key_message_ = message;
 }
 
 void ClearKeyCdm::Client::NeedKey(const std::string& key_system,
@@ -236,14 +233,15 @@ cdm::Status ClearKeyCdm::GenerateKeyRequest(const char* type, int type_size,
   latest_session_id_ = client_.session_id();
 
   DCHECK(!key_request->message());
-  if (client_.key_message_length()) {
+  if (!client_.key_message().empty()) {
     // TODO(tomfinegan): Get rid of this copy.
     key_request->set_message(
-        allocator_->Allocate(client_.key_message_length()));
+        allocator_->Allocate(client_.key_message().size()));
     DCHECK(key_request->message());
-    DCHECK_EQ(key_request->message()->size(), client_.key_message_length());
+    DCHECK_EQ(static_cast<size_t>(key_request->message()->size()),
+              client_.key_message().size());
     memcpy(key_request->message()->data(),
-           client_.key_message(), client_.key_message_length());
+           client_.key_message().data(), client_.key_message().size());
   }
 
   key_request->set_default_url(client_.default_url().data(),
diff --git a/webkit/media/crypto/ppapi/clear_key_cdm.h b/webkit/media/crypto/ppapi/clear_key_cdm.h
index 83fd9e1..49a3fec 100644
--- a/webkit/media/crypto/ppapi/clear_key_cdm.h
+++ b/webkit/media/crypto/ppapi/clear_key_cdm.h
@@ -78,8 +78,7 @@ class ClearKeyCdm : public cdm::ContentDecryptionModule {
 
     Status status() { return status_; }
     const std::string& session_id() { return session_id_; }
-    const uint8* key_message() { return key_message_.get(); }
-    int key_message_length() { return key_message_length_; }
+    const std::string& key_message() { return key_message_; }
     const std::string& default_url() { return default_url_; }
 
     // Resets the Client to a clean state.
@@ -94,8 +93,7 @@ class ClearKeyCdm : public cdm::ContentDecryptionModule {
                           int system_code) OVERRIDE;
     virtual void KeyMessage(const std::string& key_system,
                             const std::string& session_id,
-                            scoped_array<uint8> message,
-                            int message_length,
+                            const std::string& message,
                             const std::string& default_url) OVERRIDE;
     virtual void NeedKey(const std::string& key_system,
                          const std::string& session_id,
@@ -106,8 +104,7 @@ class ClearKeyCdm : public cdm::ContentDecryptionModule {
    private:
     Status status_;
     std::string session_id_;
-    scoped_array<uint8> key_message_;
-    int key_message_length_;
+    std::string key_message_;
     std::string default_url_;
   };
 
diff --git a/webkit/media/webmediaplayer_impl.cc b/webkit/media/webmediaplayer_impl.cc
index 27c8a21..88ba77b 100644
--- a/webkit/media/webmediaplayer_impl.cc
+++ b/webkit/media/webmediaplayer_impl.cc
@@ -1076,15 +1076,14 @@ void WebMediaPlayerImpl::OnKeyError(const std::string& key_system,
 
 void WebMediaPlayerImpl::OnKeyMessage(const std::string& key_system,
                                       const std::string& session_id,
-                                      scoped_array<uint8> message,
-                                      int message_length,
+                                      const std::string& message,
                                       const std::string& /* default_url */) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GetClient()->keyMessage(WebString::fromUTF8(key_system),
                           WebString::fromUTF8(session_id),
-                          message.get(),
-                          message_length);
+                          reinterpret_cast<const uint8*>(message.data()),
+                          message.size());
 }
 
 void WebMediaPlayerImpl::SetOpaque(bool opaque) {
diff --git a/webkit/media/webmediaplayer_impl.h b/webkit/media/webmediaplayer_impl.h
index e8f5b13..dc02de3 100644
--- a/webkit/media/webmediaplayer_impl.h
+++ b/webkit/media/webmediaplayer_impl.h
@@ -241,8 +241,7 @@ class WebMediaPlayerImpl
                   int system_code);
   void OnKeyMessage(const std::string& key_system,
                     const std::string& session_id,
-                    scoped_array<uint8> message,
-                    int message_length,
+                    const std::string& message,
                     const std::string& default_url);
   void OnNeedKey(const std::string& key_system,
                  const std::string& type,
diff --git a/webkit/media/webmediaplayer_proxy.cc b/webkit/media/webmediaplayer_proxy.cc
index 13941bf..6f495dd 100644
--- a/webkit/media/webmediaplayer_proxy.cc
+++ b/webkit/media/webmediaplayer_proxy.cc
@@ -125,12 +125,11 @@ void WebMediaPlayerProxy::KeyError(const std::string& key_system,
 
 void WebMediaPlayerProxy::KeyMessage(const std::string& key_system,
                                      const std::string& session_id,
-                                     scoped_array<uint8> message,
-                                     int message_length,
+                                     const std::string& message,
                                      const std::string& default_url) {
   render_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerProxy::KeyMessageTask, this, key_system, session_id,
-      base::Passed(&message), message_length, default_url));
+      message, default_url));
 }
 
 void WebMediaPlayerProxy::NeedKey(const std::string& key_system,
@@ -162,13 +161,11 @@ void WebMediaPlayerProxy::KeyErrorTask(const std::string& key_system,
 
 void WebMediaPlayerProxy::KeyMessageTask(const std::string& key_system,
                                          const std::string& session_id,
-                                         scoped_array<uint8> message,
-                                         int message_length,
+                                         const std::string& message,
                                          const std::string& default_url) {
   DCHECK(render_loop_->BelongsToCurrentThread());
   if (webmediaplayer_)
-    webmediaplayer_->OnKeyMessage(key_system, session_id,
-                                  message.Pass(), message_length, default_url);
+    webmediaplayer_->OnKeyMessage(key_system, session_id, message, default_url);
 }
 
 void WebMediaPlayerProxy::NeedKeyTask(const std::string& key_system,
diff --git a/webkit/media/webmediaplayer_proxy.h b/webkit/media/webmediaplayer_proxy.h
index 2c474ad..b16d267 100644
--- a/webkit/media/webmediaplayer_proxy.h
+++ b/webkit/media/webmediaplayer_proxy.h
@@ -80,8 +80,7 @@ class WebMediaPlayerProxy
                         int system_code) OVERRIDE;
   virtual void KeyMessage(const std::string& key_system,
                           const std::string& session_id,
-                          scoped_array<uint8> message,
-                          int message_length,
+                          const std::string& message,
                           const std::string& default_url) OVERRIDE;
   virtual void NeedKey(const std::string& key_system,
                        const std::string& session_id,
@@ -109,8 +108,7 @@ class WebMediaPlayerProxy
   // Notify |webmediaplayer_| that a key message has been generated.
   void KeyMessageTask(const std::string& key_system,
                       const std::string& session_id,
-                      scoped_array<uint8> message,
-                      int message_length,
+                      const std::string& message,
                       const std::string& default_url);
 
   // Notify |webmediaplayer_| that a key is needed for decryption.
diff --git a/webkit/plugins/ppapi/content_decryptor_delegate.cc b/webkit/plugins/ppapi/content_decryptor_delegate.cc
index fd8f8ed..8b75102 100644
--- a/webkit/plugins/ppapi/content_decryptor_delegate.cc
+++ b/webkit/plugins/ppapi/content_decryptor_delegate.cc
@@ -655,8 +655,7 @@ void ContentDecryptorDelegate::KeyMessage(PP_Var key_system_var,
     return;
   }
 
-  scoped_array<uint8> message_array;
-  int message_size = 0;
+  std::string message;
 
   if (message_resource) {
     EnterResourceNoLock<PPB_Buffer_API> enter(message_resource, true);
@@ -677,15 +676,13 @@ void ContentDecryptorDelegate::KeyMessage(PP_Var key_system_var,
       return;
     }
 
-    message_size = mapper.size();
-    message_array.reset(new uint8[message_size]);
-    memcpy(message_array.get(), mapper.data(), mapper.size());
+    message = std::string(reinterpret_cast<const char*>(mapper.data()),
+                          mapper.size());
   }
 
   decryptor_client_->KeyMessage(key_system_string->value(),
                                 session_id_string->value(),
-                                message_array.Pass(),
-                                message_size,
+                                message,
                                 default_url_string->value());
 }