Source release v3.1.0

2016-07-19 18:43:15 -07:00
parent 7a7f78d654
commit 643b91b616
108 changed files with 16537 additions and 7174 deletions
--- a/core/test/device_files_unittest.cpp
+++ b/core/test/device_files_unittest.cpp
@@ -1408,23 +1408,49 @@ UsageInfo kUsageInfoTestData[] = {
         "0E12202FF1FBA9926A24A1F79970EC427DDF87B4421488F7952499BC33CEB282D9E48"
         "A")}};

-const std::string kTestOrigin = "com.google";
+struct HlsAttributesInfo {
+  std::string key_set_id;
+  CdmHlsMethod method;
+  std::string media_segment_iv;
+  std::string file_data;
+};
+
+HlsAttributesInfo kHlsAttributesTestData[] = {
+    {
+        "ksidC8EAA2579A282EB0", kHlsMethodAes128,  // hls attributes 0
+        a2bs_hex("F7C4D15BD466BF285E241A4E58638543"),
+        a2bs_hex("0A1A08041001321408011210F7C4D15BD466BF285E241A4E5863854312201"
+                 "39114B0372FF80FADF92614106E27BE8BD1588B4CAE6E1AEFB7F9C34EA52E"
+                 "CC"),
+    },
+    {
+        "ksidE8C37662C88DC673", kHlsMethodSampleAes,  // hls attributes 1
+        a2bs_hex("16413F038088438B5D4CD99F03EBB3D8"),
+        a2bs_hex("0A1A0804100132140802121016413F038088438B5D4CD99F03EBB3D812205"
+                 "9EA13188B75C55D1EB78B3A65DB3EA3F43BD1B16642266D988E3543943C5F"
+                 "41"),
+    }};

 class MockFile : public File {
 public:
-  MOCK_METHOD2(Open, bool(const std::string&, int flags));
-  MOCK_METHOD0(Close, void());
+  MockFile() : File(NULL) {}
+  ~MockFile() {}

  MOCK_METHOD2(Read, ssize_t(char*, size_t));
  MOCK_METHOD2(Write, ssize_t(const char*, size_t));
+  MOCK_METHOD0(Close, void());
+};
+
+class MockFileSystem : public FileSystem {
+ public:
+  MockFileSystem() {}
+  ~MockFileSystem() {}
+
+  MOCK_METHOD2(Open, File*(const std::string&, int flags));
+  MOCK_METHOD0(IsFactoryReset, bool());

  MOCK_METHOD1(Exists, bool(const std::string&));
  MOCK_METHOD1(Remove, bool(const std::string&));
-  MOCK_METHOD2(Copy, bool(const std::string&, const std::string&));
-  MOCK_METHOD2(List, bool(const std::string&, std::vector<std::string>*));
-  MOCK_METHOD1(CreateDirectory, bool(const std::string));
-  MOCK_METHOD1(IsDirectory, bool(const std::string&));
-  MOCK_METHOD1(IsRegularFile, bool(const std::string&));
  MOCK_METHOD1(FileSize, ssize_t(const std::string&));
 };

@@ -1490,21 +1516,9 @@ class DeviceFilesTest : public ::testing::Test {
 class DeviceFilesStoreTest : public DeviceFilesTest,
                             public ::testing::WithParamInterface<bool> {};

-struct CertStorageVariant {
-  CertStorageVariant(bool dir_exists_value, const std::string& origin_value)
-      : dir_exists(dir_exists_value), origin(origin_value) {}
+class DeviceCertificateStoreTest : public DeviceFilesTest {};

-  const bool dir_exists;
-  const std::string origin;
-};
-
-class DeviceCertificateStoreTest
-    : public DeviceFilesTest,
-      public ::testing::WithParamInterface<CertStorageVariant> {};
-
-class DeviceCertificateTest
-    : public DeviceFilesTest,
-      public ::testing::WithParamInterface<std::string> {};
+class DeviceCertificateTest : public DeviceFilesTest {};

 class DeviceFilesSecurityLevelTest
    : public DeviceFilesTest,
@@ -1513,13 +1527,22 @@ class DeviceFilesSecurityLevelTest
 class DeviceFilesUsageInfoTest : public DeviceFilesTest,
                                 public ::testing::WithParamInterface<int> {};

-MATCHER(IsCreateFileFlagSet, "") { return File::kCreate & arg; }
-MATCHER(IsBinaryFileFlagSet, "") { return File::kBinary & arg; }
+class DeviceFilesHlsAttributesTest
+    : public DeviceFilesTest,
+      public ::testing::WithParamInterface<HlsAttributesInfo*> {};
+
+MATCHER(IsCreateFileFlagSet, "") { return FileSystem::kCreate & arg; }
 MATCHER_P(IsStrEq, str, "") {
  // Estimating the length of data. We can have gmock provide length
  // as well as pointer to data but that will introduce a dependency on tr1
  return memcmp(arg, str.c_str(), str.size()) == 0;
 }
+MATCHER_P2(Contains, str1, size, "") {
+  // Estimating the length of data. We can have gmock provide length
+  // as well as pointer to data but that will introduce a dependency on tr1
+  std::string data(arg, size + str1.size() + kProtobufEstimatedOverhead);
+  return (data.find(str1) != std::string::npos);
+}
 MATCHER_P3(Contains, str1, str2, size, "") {
  // Estimating the length of data. We can have gmock provide length
  // as well as pointer to data but that will introduce a dependency on tr1
@@ -1586,105 +1609,78 @@ MATCHER_P7(Contains, str1, str2, str3, str4, str5, str6, map7, "") {
          data.find(str6) != std::string::npos && map7_entries_present);
 }

-TEST_P(DeviceCertificateStoreTest, StoreCertificate) {
-  MockFile file;
-  CertStorageVariant params = GetParam();
+TEST_F(DeviceCertificateStoreTest, StoreCertificate) {
+  MockFileSystem file_system;
  std::string certificate(GenerateRandomData(kCertificateLen));
  std::string wrapped_private_key(GenerateRandomData(kWrappedKeyLen));
  std::string device_certificate_path =
-      device_base_path_ + DeviceFiles::GetCertificateFileName(params.origin);
+      device_base_path_ + DeviceFiles::GetCertificateFileName();

-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_)))
-      .WillOnce(Return(params.dir_exists));
-  if (params.dir_exists) {
-    EXPECT_CALL(file, CreateDirectory(_)).Times(0);
-  } else {
-    EXPECT_CALL(file, CreateDirectory(StrEq(device_base_path_)))
-        .WillOnce(Return(true));
-  }
-
-  EXPECT_CALL(file, Open(StrEq(device_certificate_path),
-                         AllOf(IsCreateFileFlagSet(), IsBinaryFileFlagSet())))
-      .WillOnce(Return(true));
+  MockFile file;
+  EXPECT_CALL(file_system,
+              Open(StrEq(device_certificate_path), IsCreateFileFlagSet()))
+      .WillOnce(Return(&file));
  EXPECT_CALL(file, Write(Contains(certificate, wrapped_private_key, 0),
                          Gt(certificate.size() + wrapped_private_key.size())))
      .WillOnce(ReturnArg<1>());
  EXPECT_CALL(file, Close()).Times(1);
  EXPECT_CALL(file, Read(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
-  EXPECT_TRUE(device_files.StoreCertificate(params.origin, certificate,
-                                            wrapped_private_key));
+  EXPECT_TRUE(device_files.StoreCertificate(certificate, wrapped_private_key));
 }

-INSTANTIATE_TEST_CASE_P(
-    StoreCertificate, DeviceCertificateStoreTest,
-    ::testing::Values(CertStorageVariant(true, EMPTY_ORIGIN),
-                      CertStorageVariant(true, kTestOrigin),
-                      CertStorageVariant(false, EMPTY_ORIGIN),
-                      CertStorageVariant(false, kTestOrigin)));
-
-TEST_P(DeviceCertificateTest, ReadCertificate) {
-  MockFile file;
-  std::string origin = GetParam();
+TEST_F(DeviceCertificateTest, ReadCertificate) {
+  MockFileSystem file_system;
  std::string device_certificate_path =
-      device_base_path_ + DeviceFiles::GetCertificateFileName(origin);
+      device_base_path_ + DeviceFiles::GetCertificateFileName();
  std::string data = a2bs_hex(kTestCertificateFileData);

-  EXPECT_CALL(file, Exists(StrEq(device_certificate_path)))
+  MockFile file;
+  EXPECT_CALL(file_system, Exists(StrEq(device_certificate_path)))
      .WillOnce(Return(true));
-  EXPECT_CALL(file, FileSize(StrEq(device_certificate_path)))
+  EXPECT_CALL(file_system, FileSize(StrEq(device_certificate_path)))
      .WillOnce(Return(data.size()));
-  EXPECT_CALL(file, Open(StrEq(device_certificate_path), IsBinaryFileFlagSet()))
-      .WillOnce(Return(true));
+  EXPECT_CALL(file_system, Open(StrEq(device_certificate_path), _))
+      .WillOnce(Return(&file));
  EXPECT_CALL(file, Read(NotNull(), Eq(data.size())))
      .WillOnce(DoAll(SetArrayArgument<0>(data.begin(), data.end()),
                      Return(data.size())));
  EXPECT_CALL(file, Close()).Times(1);
  EXPECT_CALL(file, Write(_, _)).Times(0);
-  if (Properties::security_level_path_backward_compatibility_support()) {
-    EXPECT_CALL(file, List(_, NotNull())).WillOnce(Return(false));
-  }

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);

  std::string certificate, wrapped_private_key;
-  ASSERT_TRUE(device_files.RetrieveCertificate(origin, &certificate,
-                                               &wrapped_private_key));
+  ASSERT_TRUE(
+      device_files.RetrieveCertificate(&certificate, &wrapped_private_key));
  EXPECT_EQ(kTestCertificate, b2a_hex(certificate));
  EXPECT_EQ(kTestWrappedPrivateKey, b2a_hex(wrapped_private_key));
 }

-TEST_P(DeviceCertificateTest, HasCertificate) {
-  MockFile file;
-  std::string origin = GetParam();
+TEST_F(DeviceCertificateTest, HasCertificate) {
+  MockFileSystem file_system;
  std::string device_certificate_path =
-      device_base_path_ + DeviceFiles::GetCertificateFileName(origin);
+      device_base_path_ + DeviceFiles::GetCertificateFileName();

-  EXPECT_CALL(file, Exists(StrEq(device_certificate_path)))
+  EXPECT_CALL(file_system, Exists(StrEq(device_certificate_path)))
      .WillOnce(Return(false))
      .WillOnce(Return(true));
-  EXPECT_CALL(file, Open(_, _)).Times(0);
+  EXPECT_CALL(file_system, Open(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  ASSERT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);

  // MockFile returns false.
-  EXPECT_FALSE(device_files.HasCertificate(origin));
+  EXPECT_FALSE(device_files.HasCertificate());
  // MockFile returns true.
-  EXPECT_TRUE(device_files.HasCertificate(origin));
+  EXPECT_TRUE(device_files.HasCertificate());
 }

-INSTANTIATE_TEST_CASE_P(CertificateUseTests, DeviceCertificateTest,
-                        ::testing::Values(EMPTY_ORIGIN, kTestOrigin));
-
 TEST_P(DeviceFilesSecurityLevelTest, SecurityLevel) {
-  MockFile file;
+  MockFileSystem file_system;
  std::string certificate(GenerateRandomData(kCertificateLen));
  std::string wrapped_private_key(GenerateRandomData(kWrappedKeyLen));

@@ -1693,55 +1689,39 @@ TEST_P(DeviceFilesSecurityLevelTest, SecurityLevel) {
  ASSERT_TRUE(
      Properties::GetDeviceFilesBasePath(security_level, &device_base_path));
  std::string device_certificate_path =
-      device_base_path + DeviceFiles::GetCertificateFileName(EMPTY_ORIGIN);
+      device_base_path + DeviceFiles::GetCertificateFileName();

-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path)))
-      .WillOnce(Return(false));
-  EXPECT_CALL(file, CreateDirectory(StrEq(device_base_path)))
-      .WillOnce(Return(true));
-
-  EXPECT_CALL(file, Open(StrEq(device_certificate_path),
-                         AllOf(IsCreateFileFlagSet(), IsBinaryFileFlagSet())))
-      .WillOnce(Return(true));
+  MockFile file;
+  EXPECT_CALL(file_system,
+              Open(StrEq(device_certificate_path), IsCreateFileFlagSet()))
+      .WillOnce(Return(&file));
  EXPECT_CALL(file, Write(Contains(certificate, wrapped_private_key, 0),
                          Gt(certificate.size() + wrapped_private_key.size())))
      .WillOnce(ReturnArg<1>());
  EXPECT_CALL(file, Close()).Times(1);
  EXPECT_CALL(file, Read(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(security_level));
-  device_files.SetTestFile(&file);
-  EXPECT_TRUE(device_files.StoreCertificate(EMPTY_ORIGIN, certificate,
-                                            wrapped_private_key));
+  EXPECT_TRUE(device_files.StoreCertificate(certificate, wrapped_private_key));
 }

 INSTANTIATE_TEST_CASE_P(SecurityLevel, DeviceFilesSecurityLevelTest,
                        ::testing::Values(kSecurityLevelL1, kSecurityLevelL3));

 TEST_P(DeviceFilesStoreTest, StoreLicense) {
-  MockFile file;
+  MockFileSystem file_system;
  size_t license_num = 0;
  std::string license_path = device_base_path_ +
                             license_test_data[license_num].key_set_id +
                             DeviceFiles::GetLicenseFileNameExtension();

-  bool dir_exists = GetParam();
-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_)))
-      .WillOnce(Return(dir_exists));
-  if (dir_exists) {
-    EXPECT_CALL(file, CreateDirectory(_)).Times(0);
-  } else {
-    EXPECT_CALL(file, CreateDirectory(StrEq(device_base_path_)))
-        .WillOnce(Return(true));
-  }
-
  CdmAppParameterMap app_parameters =
      GetAppParameters(license_test_data[license_num].app_parameters);

-  EXPECT_CALL(file, Open(StrEq(license_path),
-                         AllOf(IsCreateFileFlagSet(), IsBinaryFileFlagSet())))
-      .WillOnce(Return(true));
+  MockFile file;
+  EXPECT_CALL(file_system, Open(StrEq(license_path), IsCreateFileFlagSet()))
+      .WillOnce(Return(&file));
  EXPECT_CALL(
      file, Write(Contains(license_test_data[license_num].pssh_data,
                           license_test_data[license_num].key_request,
@@ -1755,9 +1735,8 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
  EXPECT_CALL(file, Close()).Times(1);
  EXPECT_CALL(file, Read(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
  EXPECT_TRUE(device_files.StoreLicense(
      license_test_data[license_num].key_set_id,
      license_test_data[license_num].license_state,
@@ -1774,11 +1753,8 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
 INSTANTIATE_TEST_CASE_P(StoreLicense, DeviceFilesStoreTest, ::testing::Bool());

 TEST_F(DeviceFilesTest, StoreLicenses) {
+  MockFileSystem file_system;
  MockFile file;
-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_)))
-      .Times(kNumberOfLicenses)
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(file, CreateDirectory(_)).Times(0);

  for (size_t i = 0; i < kNumberOfLicenses; ++i) {
    std::string license_path = device_base_path_ +
@@ -1788,9 +1764,8 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
    CdmAppParameterMap app_parameters =
        GetAppParameters(license_test_data[i].app_parameters);

-    EXPECT_CALL(file, Open(StrEq(license_path),
-                           AllOf(IsCreateFileFlagSet(), IsBinaryFileFlagSet())))
-        .WillOnce(Return(true));
+    EXPECT_CALL(file_system, Open(StrEq(license_path), IsCreateFileFlagSet()))
+        .WillOnce(Return(&file));

    EXPECT_CALL(file, Write(Contains(license_test_data[i].pssh_data,
                                     license_test_data[i].key_request,
@@ -1805,9 +1780,8 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
  EXPECT_CALL(file, Close()).Times(kNumberOfLicenses);
  EXPECT_CALL(file, Read(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
  for (size_t i = 0; i < kNumberOfLicenses; i++) {
    CdmAppParameterMap app_parameters =
        GetAppParameters(license_test_data[i].app_parameters);
@@ -1825,6 +1799,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
 }

 TEST_F(DeviceFilesTest, RetrieveLicenses) {
+  MockFileSystem file_system;
  MockFile file;

  for (size_t i = 0; i < kNumberOfLicenses; ++i) {
@@ -1834,10 +1809,12 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {

    size_t size = license_test_data[i].file_data.size();

-    EXPECT_CALL(file, Exists(StrEq(license_path))).WillOnce(Return(true));
-    EXPECT_CALL(file, FileSize(StrEq(license_path))).WillOnce(Return(size));
-    EXPECT_CALL(file, Open(StrEq(license_path), IsBinaryFileFlagSet()))
+    EXPECT_CALL(file_system, Exists(StrEq(license_path)))
        .WillOnce(Return(true));
+    EXPECT_CALL(file_system, FileSize(StrEq(license_path)))
+        .WillOnce(Return(size));
+    EXPECT_CALL(file_system, Open(StrEq(license_path), _))
+        .WillOnce(Return(&file));
    EXPECT_CALL(file, Read(NotNull(), Eq(size)))
        .WillOnce(
            DoAll(SetArrayArgument<0>(license_test_data[i].file_data.begin(),
@@ -1847,9 +1824,8 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
  EXPECT_CALL(file, Close()).Times(kNumberOfLicenses);
  EXPECT_CALL(file, Write(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
  CdmInitData pssh_data;
  CdmKeyMessage key_request;
  CdmKeyResponse key_response;
@@ -1886,7 +1862,7 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
 }

 TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
-  MockFile file;
+  MockFileSystem file_system;
  LicenseInfo* test_data =
      &license_app_parameters_backwards_compatibility_test_data;

@@ -1895,10 +1871,12 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {

  size_t size = test_data->file_data.size();

-  EXPECT_CALL(file, Exists(StrEq(license_path))).WillOnce(Return(true));
-  EXPECT_CALL(file, FileSize(StrEq(license_path))).WillOnce(Return(size));
-  EXPECT_CALL(file, Open(StrEq(license_path), IsBinaryFileFlagSet()))
-      .WillOnce(Return(true));
+  MockFile file;
+  EXPECT_CALL(file_system, Exists(StrEq(license_path))).WillOnce(Return(true));
+  EXPECT_CALL(file_system, FileSize(StrEq(license_path)))
+      .WillOnce(Return(size));
+  EXPECT_CALL(file_system, Open(StrEq(license_path), _))
+      .WillOnce(Return(&file));
  EXPECT_CALL(file, Read(NotNull(), Eq(size)))
      .WillOnce(DoAll(SetArrayArgument<0>(test_data->file_data.begin(),
                                          test_data->file_data.end()),
@@ -1907,9 +1885,8 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
  EXPECT_CALL(file, Close()).Times(1);
  EXPECT_CALL(file, Write(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
  DeviceFiles::LicenseState license_state;
  CdmInitData pssh_data;
  CdmKeyMessage key_request;
@@ -1936,102 +1913,16 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
  EXPECT_EQ(0u, app_parameters.size());
 }

-TEST_F(DeviceFilesTest, SecurityLevelPathBackwardCompatibility) {
-  if (!Properties::security_level_path_backward_compatibility_support()) {
-    return;
-  }
-
-  MockFile file;
-  std::vector<std::string> security_dirs;
-  EXPECT_TRUE(Properties::GetSecurityLevelDirectories(&security_dirs));
-
-  size_t pos = std::string::npos;
-  for (size_t i = 0; i < security_dirs.size(); ++i) {
-    pos = device_base_path_.rfind(security_dirs[i]);
-    if (std::string::npos != pos) break;
-  }
-
-  EXPECT_NE(std::string::npos, pos);
-
-  std::string base_path(device_base_path_, 0, pos);
-  std::vector<std::string> old_files;
-  std::string new_path;
-  for (size_t i = 0; i < security_dirs.size(); ++i) {
-    old_files.push_back(security_dirs[i]);
-    new_path = base_path + security_dirs[i];
-    EXPECT_CALL(file, IsRegularFile(StrEq(new_path))).WillOnce(Return(false));
-    EXPECT_CALL(file, Exists(StrEq(new_path)))
-        .WillOnce(Return(false))
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(file, CreateDirectory(StrEq(new_path))).WillOnce(Return(true));
-  }
-
-  std::string old_path =
-      base_path + DeviceFiles::GetCertificateFileName(EMPTY_ORIGIN);
-  old_files.push_back(DeviceFiles::GetCertificateFileName(EMPTY_ORIGIN));
-  EXPECT_CALL(file, IsRegularFile(StrEq(old_path))).WillOnce(Return(true));
-  EXPECT_CALL(file, Remove(StrEq(old_path))).WillOnce(Return(true));
-  for (size_t i = 0; i < security_dirs.size(); ++i) {
-    new_path = base_path + security_dirs[i] +
-               DeviceFiles::GetCertificateFileName(EMPTY_ORIGIN);
-    EXPECT_CALL(file, Copy(StrEq(old_path), StrEq(new_path)))
-        .WillOnce(Return(true));
-  }
-
-  for (size_t j = 0; j < kNumberOfLicenses; ++j) {
-    std::string file_name = license_test_data[j].key_set_id +
-                            DeviceFiles::GetLicenseFileNameExtension();
-    old_path = base_path + file_name;
-    old_files.push_back(file_name);
-    EXPECT_CALL(file, IsRegularFile(StrEq(old_path))).WillOnce(Return(true));
-    EXPECT_CALL(file, Remove(StrEq(old_path))).WillOnce(Return(true));
-    for (size_t i = 0; i < security_dirs.size(); ++i) {
-      new_path = base_path + security_dirs[i] + file_name;
-      EXPECT_CALL(file, Copy(StrEq(old_path), StrEq(new_path)))
-          .WillOnce(Return(true));
-    }
-  }
-
-  EXPECT_CALL(file, List(StrEq(base_path), NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>(old_files), Return(true)));
-
-  std::string data = a2bs_hex(kTestCertificateFileData);
-
-  new_path =
-      device_base_path_ + DeviceFiles::GetCertificateFileName(EMPTY_ORIGIN);
-  EXPECT_CALL(file, Exists(StrEq(new_path))).WillOnce(Return(true));
-  EXPECT_CALL(file, FileSize(_)).WillOnce(Return(data.size()));
-  EXPECT_CALL(file, Open(_, _)).WillOnce(Return(true));
-  EXPECT_CALL(file, Read(NotNull(), Eq(data.size())))
-      .WillOnce(DoAll(SetArrayArgument<0>(data.begin(), data.end()),
-                      Return(data.size())));
-  EXPECT_CALL(file, Close()).Times(1);
-  EXPECT_CALL(file, Write(_, _)).Times(0);
-
-  DeviceFiles device_files;
-  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
-
-  Properties::Init();
-  std::string certificate, wrapped_private_key;
-  ASSERT_TRUE(device_files.RetrieveCertificate(EMPTY_ORIGIN, &certificate,
-                                               &wrapped_private_key));
-}
-
 TEST_F(DeviceFilesTest, UpdateLicenseState) {
-  MockFile file;
+  MockFileSystem file_system;
  std::string license_path = device_base_path_ +
                             license_update_test_data[0].key_set_id +
                             DeviceFiles::GetLicenseFileNameExtension();

-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_)))
+  MockFile file;
+  EXPECT_CALL(file_system, Open(StrEq(license_path), IsCreateFileFlagSet()))
      .Times(2)
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(file, CreateDirectory(_)).Times(0);
-  EXPECT_CALL(file, Open(StrEq(license_path),
-                         AllOf(IsCreateFileFlagSet(), IsBinaryFileFlagSet())))
-      .Times(2)
-      .WillRepeatedly(Return(true));
+      .WillRepeatedly(Return(&file));
  EXPECT_CALL(file, Write(IsStrEq(license_update_test_data[0].file_data),
                          Eq(license_update_test_data[0].file_data.size())))
      .WillOnce(ReturnArg<1>());
@@ -2041,9 +1932,8 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
  EXPECT_CALL(file, Close()).Times(2);
  EXPECT_CALL(file, Read(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
  EXPECT_TRUE(device_files.StoreLicense(
      license_update_test_data[0].key_set_id,
      license_update_test_data[0].license_state,
@@ -2072,32 +1962,33 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
 }

 TEST_F(DeviceFilesTest, DeleteLicense) {
-  MockFile file;
+  MockFileSystem file_system;
  std::string license_path = device_base_path_ +
                             license_test_data[0].key_set_id +
                             DeviceFiles::GetLicenseFileNameExtension();

  size_t size = license_test_data[0].file_data.size();

-  EXPECT_CALL(file, Exists(StrEq(license_path)))
+  MockFile file;
+  EXPECT_CALL(file_system, Exists(StrEq(license_path)))
      .Times(2)
      .WillOnce(Return(true))
      .WillOnce(Return(false));
-  EXPECT_CALL(file, FileSize(StrEq(license_path))).WillOnce(Return(size));
-  EXPECT_CALL(file, Open(StrEq(license_path), IsBinaryFileFlagSet()))
-      .WillOnce(Return(true));
+  EXPECT_CALL(file_system, FileSize(StrEq(license_path)))
+      .WillOnce(Return(size));
+  EXPECT_CALL(file_system, Open(StrEq(license_path), _))
+      .WillOnce(Return(&file));
  EXPECT_CALL(file, Read(NotNull(), Eq(size)))
      .WillOnce(
          DoAll(SetArrayArgument<0>(license_test_data[0].file_data.begin(),
                                    license_test_data[0].file_data.end()),
                Return(size)));
-  EXPECT_CALL(file, Remove(StrEq(license_path))).WillOnce(Return(true));
+  EXPECT_CALL(file_system, Remove(StrEq(license_path))).WillOnce(Return(true));
  EXPECT_CALL(file, Close()).Times(1);
  EXPECT_CALL(file, Write(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
  DeviceFiles::LicenseState license_state;
  CdmInitData pssh_data;
  CdmKeyMessage key_request;
@@ -2135,17 +2026,11 @@ TEST_F(DeviceFilesTest, DeleteLicense) {

 TEST_F(DeviceFilesTest, ReserveLicenseIdsDoesNotUseFileSystem) {
  // Validate that ReserveLicenseIds does not touch the file system.
-  MockFile file;
-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_))).Times(0);
-  EXPECT_CALL(file, CreateDirectory(_)).Times(0);
-  EXPECT_CALL(file, Open(_, _)).Times(0);
-  EXPECT_CALL(file, Write(_, _)).Times(0);
-  EXPECT_CALL(file, Close()).Times(0);
-  EXPECT_CALL(file, Read(_, _)).Times(0);
+  MockFileSystem file_system;
+  EXPECT_CALL(file_system, Open(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);
  for (size_t i = 0; i < kNumberOfLicenses; i++) {
    EXPECT_TRUE(device_files.ReserveLicenseId(license_test_data[i].key_set_id));
    // Validate that the license IDs are actually reserved.
@@ -2156,6 +2041,7 @@ TEST_F(DeviceFilesTest, ReserveLicenseIdsDoesNotUseFileSystem) {
 }

 TEST_P(DeviceFilesUsageInfoTest, Read) {
+  MockFileSystem file_system;
  MockFile file;
  std::string app_id;  // TODO(fredgc): add tests with multiple app_ids.
  std::string path =
@@ -2167,28 +2053,24 @@ TEST_P(DeviceFilesUsageInfoTest, Read) {
    data = kUsageInfoTestData[index].file_data;
  }
  if (index >= 0) {
-    EXPECT_CALL(file, Exists(StrEq(path))).WillRepeatedly(Return(true));
-    EXPECT_CALL(file, FileSize(StrEq(path)))
+    EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true));
+    EXPECT_CALL(file_system, FileSize(StrEq(path)))
        .WillRepeatedly(Return(data.size()));
-    EXPECT_CALL(file, Open(StrEq(path), IsBinaryFileFlagSet()))
-        .WillOnce(Return(true));
+    EXPECT_CALL(file_system, Open(StrEq(path), _)).WillOnce(Return(&file));
    EXPECT_CALL(file, Read(NotNull(), Eq(data.size())))
        .WillOnce(DoAll(SetArrayArgument<0>(data.begin(), data.end()),
                        Return(data.size())));
    EXPECT_CALL(file, Close()).Times(1);
  } else {
-    EXPECT_CALL(file, Exists(StrEq(path)))
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(file, FileSize(_)).Times(0);
-    EXPECT_CALL(file, Open(_, _)).Times(0);
-    EXPECT_CALL(file, Close()).Times(0);
+    EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(false));
+    EXPECT_CALL(file_system, FileSize(_)).Times(0);
+    EXPECT_CALL(file_system, Open(_, _)).Times(0);
  }

  EXPECT_CALL(file, Write(_, _)).Times(0);

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);

  std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> > license_info;
  ASSERT_TRUE(device_files.RetrieveUsageInfo(app_id, &license_info));
@@ -2212,7 +2094,7 @@ TEST_P(DeviceFilesUsageInfoTest, Read) {
 }

 TEST_P(DeviceFilesUsageInfoTest, Store) {
-  MockFile file;
+  MockFileSystem file_system;
  std::string app_id;  // TODO(fredgc): multiple app ids.
  std::string pst(GenerateRandomData(kProviderSessionTokenLen));
  std::string license_request(GenerateRandomData(kLicenseRequestLen));
@@ -2226,24 +2108,24 @@ TEST_P(DeviceFilesUsageInfoTest, Store) {
  if (index >= 0) {
    data = kUsageInfoTestData[index].file_data;
  }
-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_)))
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(file, CreateDirectory(_)).Times(0);

-  EXPECT_CALL(file, Exists(StrEq(path))).WillRepeatedly(Return(index >= 0));
+  MockFile file;
+  EXPECT_CALL(file_system, Exists(StrEq(path)))
+      .WillRepeatedly(Return(index >= 0));
  if (index >= 0) {
-    EXPECT_CALL(file, FileSize(StrEq(path))).WillOnce(Return(data.size()));
-    EXPECT_CALL(file, Open(StrEq(path), IsBinaryFileFlagSet()))
+    EXPECT_CALL(file_system, FileSize(StrEq(path)))
+        .WillOnce(Return(data.size()));
+    EXPECT_CALL(file_system, Open(StrEq(path), _))
        .Times(2)
-        .WillRepeatedly(Return(true));
+        .WillRepeatedly(Return(&file));
    EXPECT_CALL(file, Read(NotNull(), Eq(data.size())))
        .WillOnce(DoAll(SetArrayArgument<0>(data.begin(), data.end()),
                        Return(data.size())));
    EXPECT_CALL(file, Close()).Times(2);
  } else {
-    EXPECT_CALL(file, FileSize(_)).Times(0);
-    EXPECT_CALL(file, Open(_, _)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(file, Close()).Times(1);
+    EXPECT_CALL(file_system, FileSize(_)).Times(0);
+    EXPECT_CALL(file_system, Open(_, _)).Times(1).WillOnce(Return(&file));
+    EXPECT_CALL(file, Close());
  }

  EXPECT_CALL(file,
@@ -2253,9 +2135,8 @@ TEST_P(DeviceFilesUsageInfoTest, Store) {
                       key_set_id.size())))
      .WillOnce(ReturnArg<1>());

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);

  ASSERT_TRUE(
      device_files.StoreUsageInfo(pst, license_request, license, app_id,
@@ -2263,6 +2144,7 @@ TEST_P(DeviceFilesUsageInfoTest, Store) {
 }

 TEST_P(DeviceFilesUsageInfoTest, Delete) {
+  MockFileSystem file_system;
  MockFile file;
  std::string app_id;  // TODO(fredgc): expand tests.
  std::string path =
@@ -2282,24 +2164,19 @@ TEST_P(DeviceFilesUsageInfoTest, Delete) {
    }
  }

-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_)))
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(file, CreateDirectory(_)).Times(0);
+  EXPECT_CALL(file_system, Exists(StrEq(path))).WillOnce(Return(index >= 0));

-  EXPECT_CALL(file, Exists(StrEq(path))).WillOnce(Return(index >= 0));
-
-  EXPECT_CALL(file, FileSize(StrEq(path))).WillOnce(Return(data.size()));
+  EXPECT_CALL(file_system, FileSize(StrEq(path))).WillOnce(Return(data.size()));
  if (index >= 1) {
-    EXPECT_CALL(file, Open(StrEq(path), IsBinaryFileFlagSet()))
+    EXPECT_CALL(file_system, Open(StrEq(path), _))
        .Times(2)
-        .WillRepeatedly(Return(true));
+        .WillRepeatedly(Return(&file));
    EXPECT_CALL(file, Write(Contains(prev_pst, prev_license, prev_data.size()),
                            Gt(prev_pst.size() + prev_license.size())))
        .WillOnce(ReturnArg<1>());
    EXPECT_CALL(file, Close()).Times(2);
  } else {
-    EXPECT_CALL(file, Open(StrEq(path), IsBinaryFileFlagSet()))
-        .WillOnce(Return(true));
+    EXPECT_CALL(file_system, Open(StrEq(path), _)).WillOnce(Return(&file));
    EXPECT_CALL(file, Write(_, _)).Times(0);
    EXPECT_CALL(file, Close()).Times(1);
  }
@@ -2307,9 +2184,8 @@ TEST_P(DeviceFilesUsageInfoTest, Delete) {
      .WillOnce(DoAll(SetArrayArgument<0>(data.begin(), data.end()),
                      Return(data.size())));

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);

  if (index >= 1) {
    ASSERT_TRUE(device_files.DeleteUsageInfo(app_id, pst));
@@ -2319,36 +2195,33 @@ TEST_P(DeviceFilesUsageInfoTest, Delete) {
 }

 TEST_P(DeviceFilesUsageInfoTest, DeleteAll) {
+  MockFileSystem file_system;
  MockFile file;
  std::string app_id;  // TODO(fredgc): expand tests.
  std::string path =
      device_base_path_ + DeviceFiles::GetUsageInfoFileName(app_id);

  int index = GetParam();
-  EXPECT_CALL(file, IsDirectory(StrEq(device_base_path_)))
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(file, CreateDirectory(_)).Times(0);
  EXPECT_CALL(file, Write(_, _)).Times(0);

  std::string data;
  if (index < 0) {
-    EXPECT_CALL(file, Exists(StrEq(path))).WillOnce(Return(false));
+    EXPECT_CALL(file_system, Exists(StrEq(path))).WillOnce(Return(false));
  } else {
    data = kUsageInfoTestData[index].file_data;
-    EXPECT_CALL(file, Exists(StrEq(path))).WillRepeatedly(Return(true));
-    EXPECT_CALL(file, FileSize(StrEq(path))).WillOnce(Return(data.size()));
-    EXPECT_CALL(file, Open(StrEq(path), IsBinaryFileFlagSet()))
-        .WillOnce(Return(true));
+    EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true));
+    EXPECT_CALL(file_system, FileSize(StrEq(path)))
+        .WillOnce(Return(data.size()));
+    EXPECT_CALL(file_system, Open(StrEq(path), _)).WillOnce(Return(&file));
    EXPECT_CALL(file, Read(NotNull(), Eq(data.size())))
        .WillOnce(DoAll(SetArrayArgument<0>(data.begin(), data.end()),
                        Return(data.size())));
    EXPECT_CALL(file, Close()).Times(1);
-    EXPECT_CALL(file, Remove(StrEq(path))).WillOnce(Return(true));
+    EXPECT_CALL(file_system, Remove(StrEq(path))).WillOnce(Return(true));
  }

-  DeviceFiles device_files;
+  DeviceFiles device_files(&file_system);
  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
-  device_files.SetTestFile(&file);

  std::vector<std::string> psts;
  ASSERT_TRUE(device_files.DeleteAllUsageInfoForApp(app_id, &psts));
@@ -2367,4 +2240,75 @@ TEST_P(DeviceFilesUsageInfoTest, DeleteAll) {
 INSTANTIATE_TEST_CASE_P(UsageInfo, DeviceFilesUsageInfoTest,
                        ::testing::Range(-1, 4));

+TEST_P(DeviceFilesHlsAttributesTest, Read) {
+  MockFileSystem file_system;
+  MockFile file;
+  HlsAttributesInfo* param = GetParam();
+  std::string path = device_base_path_ + param->key_set_id +
+                     DeviceFiles::GetHlsAttributesFileNameExtension();
+
+  EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true));
+  EXPECT_CALL(file_system, FileSize(StrEq(path)))
+      .WillRepeatedly(Return(param->file_data.size()));
+  EXPECT_CALL(file_system, Open(StrEq(path), _)).WillOnce(Return(&file));
+  EXPECT_CALL(file, Read(NotNull(), Eq(param->file_data.size())))
+      .WillOnce(DoAll(
+          SetArrayArgument<0>(param->file_data.begin(), param->file_data.end()),
+          Return(param->file_data.size())));
+  EXPECT_CALL(file, Close()).Times(1);
+
+  EXPECT_CALL(file, Write(_, _)).Times(0);
+
+  DeviceFiles device_files(&file_system);
+  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
+
+  CdmHlsMethod method;
+  std::vector<uint8_t> media_segment_iv;
+  ASSERT_TRUE(device_files.RetrieveHlsAttributes(param->key_set_id, &method,
+                                                 &media_segment_iv));
+  EXPECT_EQ(param->method, method);
+  EXPECT_EQ(b2a_hex(param->media_segment_iv), b2a_hex(media_segment_iv));
+}
+
+TEST_P(DeviceFilesHlsAttributesTest, Store) {
+  MockFileSystem file_system;
+  MockFile file;
+  HlsAttributesInfo* param = GetParam();
+  std::string path = device_base_path_ + param->key_set_id +
+                     DeviceFiles::GetHlsAttributesFileNameExtension();
+
+  EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true));
+  EXPECT_CALL(file_system, Open(StrEq(path), _)).WillOnce(Return(&file));
+  EXPECT_CALL(file, Write(Contains(param->media_segment_iv, 0),
+                          Gt(param->media_segment_iv.size())))
+      .WillOnce(ReturnArg<1>());
+  EXPECT_CALL(file, Read(_, _)).Times(0);
+  EXPECT_CALL(file, Close()).Times(1);
+
+  DeviceFiles device_files(&file_system);
+  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
+  std::vector<uint8_t> iv(param->media_segment_iv.begin(),
+                          param->media_segment_iv.end());
+  ASSERT_TRUE(
+      device_files.StoreHlsAttributes(param->key_set_id, param->method, iv));
+}
+
+TEST_P(DeviceFilesHlsAttributesTest, Delete) {
+  MockFileSystem file_system;
+  MockFile file;
+  HlsAttributesInfo* param = GetParam();
+  std::string path = device_base_path_ + param->key_set_id +
+                     DeviceFiles::GetHlsAttributesFileNameExtension();
+
+  EXPECT_CALL(file_system, Remove(StrEq(path))).WillOnce(Return(true));
+
+  DeviceFiles device_files(&file_system);
+  EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
+  ASSERT_TRUE(device_files.DeleteHlsAttributes(param->key_set_id));
+}
+
+INSTANTIATE_TEST_CASE_P(HlsAttributes, DeviceFilesHlsAttributesTest,
+                        ::testing::Range(&kHlsAttributesTestData[0],
+                                         &kHlsAttributesTestData[2]));
+
 }  // namespace wvcdm