Using GURL in place of std::string for destination_url

media/cdm/aes_decryptor_unittest.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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/mock_filters.h"
 #include "media/cdm/aes_decryptor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
 
 using ::testing::_;
 using ::testing::Gt;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::SaveArg;
 using ::testing::StrNe;
 
 MATCHER(IsEmpty, "") { return arg.empty(); }
 
+class GURL;
+
 namespace media {
 
 const uint8 kOriginalData[] = "Original subsample data.";
 const int kOriginalDataSize = 24;
 
 // In the examples below, 'k'(key) has to be 16 bytes, and will always require
 // 2 bytes of padding. 'kid'(keyid) is variable length, and may require 0, 1,
 // or 2 bytes of padding.
 
 const uint8 kKeyId[] = {
@@ skipping 183 matching lines @@
             kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)),
         next_session_id_(1) {
   }
 
  protected:
   // Creates a new session using |key_id|. Returns the session ID.
   uint32 CreateSession(const std::vector<uint8>& key_id) {
     DCHECK(!key_id.empty());
     uint32 session_id = next_session_id_++;
     EXPECT_CALL(*this, OnSessionCreated(session_id, StrNe(std::string())));
-    EXPECT_CALL(*this, OnSessionMessage(session_id, key_id, ""));
+    EXPECT_CALL(*this, OnSessionMessage(session_id, key_id, GURL::EmptyGURL()));
     EXPECT_TRUE(decryptor_.CreateSession(
         session_id, std::string(), &key_id[0], key_id.size()));
     return session_id;
   }
 
   // Releases the session specified by |session_id|.
   void ReleaseSession(uint32 session_id) {
     EXPECT_CALL(*this, OnSessionClosed(session_id));
     decryptor_.ReleaseSession(session_id);
   }
@@ skipping 81 matching lines @@
         EXPECT_TRUE(decrypted_text.empty());
         break;
     }
   }
 
   MOCK_METHOD2(OnSessionCreated,
                void(uint32 session_id, const std::string& web_session_id));
   MOCK_METHOD3(OnSessionMessage,
                void(uint32 session_id,
                     const std::vector<uint8>& message,
-                    const std::string& default_url));
+                    const GURL& default_url));
   MOCK_METHOD1(OnSessionReady, void(uint32 session_id));
   MOCK_METHOD1(OnSessionClosed, void(uint32 session_id));
   MOCK_METHOD3(OnSessionError,
                void(uint32 session_id,
                     MediaKeys::KeyError,
                     uint32 system_code));
 
   AesDecryptor decryptor_;
   AesDecryptor::DecryptCB decrypt_cb_;
 
   // Constants for testing.
   const std::vector<uint8> original_data_;
   const std::vector<uint8> encrypted_data_;
   const std::vector<uint8> subsample_encrypted_data_;
   const std::vector<uint8> key_id_;
   const std::vector<uint8> iv_;
   const std::vector<SubsampleEntry> normal_subsample_entries_;
   const std::vector<SubsampleEntry> no_subsample_entries_;
 
   // Generate new session ID every time
   uint32 next_session_id_;
 };
 
 TEST_F(AesDecryptorTest, CreateSessionWithNullInitData) {
   uint32 session_id = 8;
-  EXPECT_CALL(*this, OnSessionMessage(session_id, IsEmpty(), ""));
+  EXPECT_CALL(*this,
+              OnSessionMessage(session_id, IsEmpty(), GURL::EmptyGURL()));
   EXPECT_CALL(*this, OnSessionCreated(session_id, StrNe(std::string())));
   EXPECT_TRUE(decryptor_.CreateSession(session_id, std::string(), NULL, 0));
 }
 
 TEST_F(AesDecryptorTest, MultipleCreateSession) {
   uint32 session_id1 = 10;
-  EXPECT_CALL(*this, OnSessionMessage(session_id1, IsEmpty(), ""));
+  EXPECT_CALL(*this,
+              OnSessionMessage(session_id1, IsEmpty(), GURL::EmptyGURL()));
   EXPECT_CALL(*this, OnSessionCreated(session_id1, StrNe(std::string())));
   EXPECT_TRUE(decryptor_.CreateSession(session_id1, std::string(), NULL, 0));
 
   uint32 session_id2 = 11;
-  EXPECT_CALL(*this, OnSessionMessage(session_id2, IsEmpty(), ""));
+  EXPECT_CALL(*this,
+              OnSessionMessage(session_id2, IsEmpty(), GURL::EmptyGURL()));
   EXPECT_CALL(*this, OnSessionCreated(session_id2, StrNe(std::string())));
   EXPECT_TRUE(decryptor_.CreateSession(session_id2, std::string(), NULL, 0));
 
   uint32 session_id3 = 23;
-  EXPECT_CALL(*this, OnSessionMessage(session_id3, IsEmpty(), ""));
+  EXPECT_CALL(*this,
+              OnSessionMessage(session_id3, IsEmpty(), GURL::EmptyGURL()));
   EXPECT_CALL(*this, OnSessionCreated(session_id3, StrNe(std::string())));
   EXPECT_TRUE(decryptor_.CreateSession(session_id3, std::string(), NULL, 0));
 }
 
 TEST_F(AesDecryptorTest, NormalDecryption) {
   uint32 session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, SESSION_READY);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
@@ skipping 369 matching lines @@
       "      \"kid\": \"\","
       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
       "    }"
       "  ]"
       "}";
   UpdateSessionAndExpect(session_id, kJwksWithEmptyKeyId, SESSION_ERROR);
   ReleaseSession(session_id);
 }
 
 }  // namespace media