Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(47)

Side by Side Diff: chrome/browser/media/encrypted_media_browsertest.cc

Issue 408993002: Have media content and chrome browser tests load data from media/test/data (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « no previous file | chrome/browser/media/encrypted_media_istypesupported_browsertest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "base/command_line.h" 5 #include "base/command_line.h"
6 #include "base/memory/scoped_ptr.h" 6 #include "base/memory/scoped_ptr.h"
7 #include "base/path_service.h" 7 #include "base/path_service.h"
8 #include "base/strings/utf_string_conversions.h" 8 #include "base/strings/utf_string_conversions.h"
9 #include "base/win/windows_version.h" 9 #include "base/win/windows_version.h"
10 #include "chrome/browser/media/media_browsertest.h" 10 #include "chrome/browser/media/media_browsertest.h"
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after
108 return key_system == kExternalClearKeyKeySystem || 108 return key_system == kExternalClearKeyKeySystem ||
109 IsParentKeySystemOf(kExternalClearKeyKeySystem, key_system); 109 IsParentKeySystemOf(kExternalClearKeyKeySystem, key_system);
110 } 110 }
111 111
112 #if defined(WIDEVINE_CDM_AVAILABLE) 112 #if defined(WIDEVINE_CDM_AVAILABLE)
113 bool IsWidevine(const std::string& key_system) { 113 bool IsWidevine(const std::string& key_system) {
114 return key_system == kWidevineKeySystem; 114 return key_system == kWidevineKeySystem;
115 } 115 }
116 #endif // defined(WIDEVINE_CDM_AVAILABLE) 116 #endif // defined(WIDEVINE_CDM_AVAILABLE)
117 117
118 void RunEncryptedMediaTestPage(const std::string& html_page, 118 void RunEncryptedMediaTestPage(
119 const std::string& key_system, 119 const std::string& html_page,
120 std::vector<StringPair>* query_params, 120 const std::string& key_system,
121 const std::string& expected_title) { 121 const media::QueryParams& query_params,
122 StartLicenseServerIfNeeded(key_system, query_params); 122 const std::string& expected_title) {
123 RunMediaTestPage(html_page, query_params, expected_title, true); 123 media::QueryParams new_query_params = query_params;
124 StartLicenseServerIfNeeded(key_system, &new_query_params);
125 RunMediaTestPage(html_page, new_query_params, expected_title, true);
124 } 126 }
125 127
126 // Tests |html_page| using |media_file| (with |media_type|) and |key_system|. 128 // Tests |html_page| using |media_file| (with |media_type|) and |key_system|.
127 // When |session_to_load| is not empty, the test will try to load 129 // When |session_to_load| is not empty, the test will try to load
128 // |session_to_load| with stored keys, instead of creating a new session 130 // |session_to_load| with stored keys, instead of creating a new session
129 // and trying to update it with licenses. 131 // and trying to update it with licenses.
130 // When |force_invalid_response| is true, the test will provide invalid 132 // When |force_invalid_response| is true, the test will provide invalid
131 // responses, which should trigger errors. 133 // responses, which should trigger errors.
132 // TODO(xhwang): Find an easier way to pass multiple configuration test 134 // TODO(xhwang): Find an easier way to pass multiple configuration test
133 // options. 135 // options.
134 void RunEncryptedMediaTest(const std::string& html_page, 136 void RunEncryptedMediaTest(const std::string& html_page,
135 const std::string& media_file, 137 const std::string& media_file,
136 const std::string& media_type, 138 const std::string& media_type,
137 const std::string& key_system, 139 const std::string& key_system,
138 SrcType src_type, 140 SrcType src_type,
139 EmeVersion eme_version, 141 EmeVersion eme_version,
140 const std::string& session_to_load, 142 const std::string& session_to_load,
141 bool force_invalid_response, 143 bool force_invalid_response,
142 const std::string& expected_title) { 144 const std::string& expected_title) {
143 if (src_type == MSE && !IsMSESupported()) { 145 if (src_type == MSE && !IsMSESupported()) {
144 VLOG(0) << "Skipping test - MSE not supported."; 146 VLOG(0) << "Skipping test - MSE not supported.";
145 return; 147 return;
146 } 148 }
147 std::vector<StringPair> query_params; 149 media::QueryParams query_params;
148 query_params.push_back(std::make_pair("mediaFile", media_file)); 150 query_params.push_back(std::make_pair("mediaFile", media_file));
149 query_params.push_back(std::make_pair("mediaType", media_type)); 151 query_params.push_back(std::make_pair("mediaType", media_type));
150 query_params.push_back(std::make_pair("keySystem", key_system)); 152 query_params.push_back(std::make_pair("keySystem", key_system));
151 if (src_type == MSE) 153 if (src_type == MSE)
152 query_params.push_back(std::make_pair("useMSE", "1")); 154 query_params.push_back(std::make_pair("useMSE", "1"));
153 if (eme_version == PREFIXED) 155 if (eme_version == PREFIXED)
154 query_params.push_back(std::make_pair("usePrefixedEME", "1")); 156 query_params.push_back(std::make_pair("usePrefixedEME", "1"));
155 if (force_invalid_response) 157 if (force_invalid_response)
156 query_params.push_back(std::make_pair("forceInvalidResponse", "1")); 158 query_params.push_back(std::make_pair("forceInvalidResponse", "1"));
157 if (!session_to_load.empty()) 159 if (!session_to_load.empty())
158 query_params.push_back(std::make_pair("sessionToLoad", session_to_load)); 160 query_params.push_back(std::make_pair("sessionToLoad", session_to_load));
159 RunEncryptedMediaTestPage(html_page, key_system, &query_params, 161 RunEncryptedMediaTestPage(html_page, key_system, query_params,
160 expected_title); 162 expected_title);
161 } 163 }
162 164
163 void RunSimpleEncryptedMediaTest(const std::string& media_file, 165 void RunSimpleEncryptedMediaTest(const std::string& media_file,
164 const std::string& media_type, 166 const std::string& media_type,
165 const std::string& key_system, 167 const std::string& key_system,
166 SrcType src_type, 168 SrcType src_type,
167 EmeVersion eme_version) { 169 EmeVersion eme_version) {
168 std::string expected_title = kEnded; 170 std::string expected_title = kEnded;
169 if (!IsPlayBackPossible(key_system)) 171 if (!IsPlayBackPossible(key_system))
(...skipping 11 matching lines...) Expand all
181 // Check KeyMessage received for all key systems. 183 // Check KeyMessage received for all key systems.
182 bool receivedKeyMessage = false; 184 bool receivedKeyMessage = false;
183 EXPECT_TRUE(content::ExecuteScriptAndExtractBool( 185 EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
184 browser()->tab_strip_model()->GetActiveWebContents(), 186 browser()->tab_strip_model()->GetActiveWebContents(),
185 "window.domAutomationController.send(" 187 "window.domAutomationController.send("
186 "document.querySelector('video').receivedKeyMessage);", 188 "document.querySelector('video').receivedKeyMessage);",
187 &receivedKeyMessage)); 189 &receivedKeyMessage));
188 EXPECT_TRUE(receivedKeyMessage); 190 EXPECT_TRUE(receivedKeyMessage);
189 } 191 }
190 192
191 193 // Starts a license server if available for the |key_system| and adds a
194 // 'licenseServerURL' query parameter to |query_params|.
192 void StartLicenseServerIfNeeded(const std::string& key_system, 195 void StartLicenseServerIfNeeded(const std::string& key_system,
193 std::vector<StringPair>* query_params) { 196 media::QueryParams* query_params) {
194 scoped_ptr<TestLicenseServerConfig> config = GetServerConfig(key_system); 197 scoped_ptr<TestLicenseServerConfig> config = GetServerConfig(key_system);
195 if (!config) 198 if (!config)
196 return; 199 return;
197 license_server_.reset(new TestLicenseServer(config.Pass())); 200 license_server_.reset(new TestLicenseServer(config.Pass()));
198 EXPECT_TRUE(license_server_->Start()); 201 EXPECT_TRUE(license_server_->Start());
199 query_params->push_back(std::make_pair("licenseServerURL", 202 query_params->push_back(
200 license_server_->GetServerURL())); 203 std::make_pair("licenseServerURL", license_server_->GetServerURL()));
201 } 204 }
202 205
203 bool IsPlayBackPossible(const std::string& key_system) { 206 bool IsPlayBackPossible(const std::string& key_system) {
204 #if defined(WIDEVINE_CDM_AVAILABLE) 207 #if defined(WIDEVINE_CDM_AVAILABLE)
205 if (IsWidevine(key_system) && !GetServerConfig(key_system)) 208 if (IsWidevine(key_system) && !GetServerConfig(key_system))
206 return false; 209 return false;
207 #endif // defined(WIDEVINE_CDM_AVAILABLE) 210 #endif // defined(WIDEVINE_CDM_AVAILABLE)
208 return true; 211 return true;
209 } 212 }
210 213
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after
305 // decrypt-and-decode mode. 308 // decrypt-and-decode mode.
306 class ECKEncryptedMediaTest : public EncryptedMediaTestBase { 309 class ECKEncryptedMediaTest : public EncryptedMediaTestBase {
307 public: 310 public:
308 // We use special |key_system| names to do non-playback related tests, e.g. 311 // We use special |key_system| names to do non-playback related tests, e.g.
309 // kExternalClearKeyFileIOTestKeySystem is used to test file IO. 312 // kExternalClearKeyFileIOTestKeySystem is used to test file IO.
310 void TestNonPlaybackCases(const std::string& key_system, 313 void TestNonPlaybackCases(const std::string& key_system,
311 const std::string& expected_title) { 314 const std::string& expected_title) {
312 // Since we do not test playback, arbitrarily choose a test file and source 315 // Since we do not test playback, arbitrarily choose a test file and source
313 // type. 316 // type.
314 RunEncryptedMediaTest(kDefaultEmePlayer, 317 RunEncryptedMediaTest(kDefaultEmePlayer,
315 "bear-a-enc_a.webm", 318 "bear-a_enc-a.webm",
316 kWebMAudioOnly, 319 kWebMAudioOnly,
317 key_system, 320 key_system,
318 SRC, 321 SRC,
319 PREFIXED, 322 PREFIXED,
320 kNoSessionToLoad, 323 kNoSessionToLoad,
321 false, 324 false,
322 expected_title); 325 expected_title);
323 } 326 }
324 327
325 protected: 328 protected:
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
372 const std::string& media_type) { 375 const std::string& media_type) {
373 RunSimpleEncryptedMediaTest(encrypted_media, 376 RunSimpleEncryptedMediaTest(encrypted_media,
374 media_type, 377 media_type,
375 CurrentKeySystem(), 378 CurrentKeySystem(),
376 CurrentSourceType(), 379 CurrentSourceType(),
377 CurrentEmeVersion()); 380 CurrentEmeVersion());
378 } 381 }
379 382
380 void RunInvalidResponseTest() { 383 void RunInvalidResponseTest() {
381 RunEncryptedMediaTest(kDefaultEmePlayer, 384 RunEncryptedMediaTest(kDefaultEmePlayer,
382 "bear-320x240-av-enc_av.webm", 385 "bear-320x240-av_enc-av.webm",
383 kWebMAudioVideo, 386 kWebMAudioVideo,
384 CurrentKeySystem(), 387 CurrentKeySystem(),
385 CurrentSourceType(), 388 CurrentSourceType(),
386 CurrentEmeVersion(), 389 CurrentEmeVersion(),
387 kNoSessionToLoad, 390 kNoSessionToLoad,
388 true, 391 true,
389 kEmeKeyError); 392 kEmeKeyError);
390 } 393 }
391 394
392 void TestFrameSizeChange() { 395 void TestFrameSizeChange() {
393 RunEncryptedMediaTest("encrypted_frame_size_change.html", 396 RunEncryptedMediaTest("encrypted_frame_size_change.html",
394 "frame_size_change-av-enc-v.webm", 397 "frame_size_change-av_enc-v.webm",
395 kWebMAudioVideo, 398 kWebMAudioVideo,
396 CurrentKeySystem(), 399 CurrentKeySystem(),
397 CurrentSourceType(), 400 CurrentSourceType(),
398 CurrentEmeVersion(), 401 CurrentEmeVersion(),
399 kNoSessionToLoad, 402 kNoSessionToLoad,
400 false, 403 false,
401 kEnded); 404 kEnded);
402 } 405 }
403 406
404 void TestConfigChange() { 407 void TestConfigChange() {
405 DCHECK(IsMSESupported()); 408 DCHECK(IsMSESupported());
406 std::vector<StringPair> query_params; 409 media::QueryParams query_params;
407 query_params.push_back(std::make_pair("keySystem", CurrentKeySystem())); 410 query_params.push_back(std::make_pair("keySystem", CurrentKeySystem()));
408 query_params.push_back(std::make_pair("runEncrypted", "1")); 411 query_params.push_back(std::make_pair("runEncrypted", "1"));
409 if (CurrentEmeVersion() == PREFIXED) 412 if (CurrentEmeVersion() == PREFIXED)
410 query_params.push_back(std::make_pair("usePrefixedEME", "1")); 413 query_params.push_back(std::make_pair("usePrefixedEME", "1"));
411 RunEncryptedMediaTestPage("mse_config_change.html", 414 RunEncryptedMediaTestPage("mse_config_change.html",
412 CurrentKeySystem(), 415 CurrentKeySystem(),
413 &query_params, 416 query_params,
414 kEnded); 417 kEnded);
415 } 418 }
416 419
417 protected: 420 protected:
418 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 421 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
419 EncryptedMediaTestBase::SetUpCommandLine(command_line); 422 EncryptedMediaTestBase::SetUpCommandLine(command_line);
420 SetUpCommandLineForKeySystem(CurrentKeySystem(), command_line); 423 SetUpCommandLineForKeySystem(CurrentKeySystem(), command_line);
421 424
422 if (CurrentEmeVersion() == UNPREFIXED) 425 if (CurrentEmeVersion() == UNPREFIXED)
423 command_line->AppendSwitch(switches::kEnableEncryptedMedia); 426 command_line->AppendSwitch(switches::kEnableEncryptedMedia);
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
481 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly_Prefixed, 484 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly_Prefixed,
482 EncryptedMediaTest, 485 EncryptedMediaTest,
483 Combine(Values(kExternalClearKeyDecryptOnlyKeySystem), 486 Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
484 Values(MSE), 487 Values(MSE),
485 Values(PREFIXED))); 488 Values(PREFIXED)));
486 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly, 489 INSTANTIATE_TEST_CASE_P(MSE_ExternalClearKeyDecryptOnly,
487 EncryptedMediaTest, 490 EncryptedMediaTest,
488 Combine(Values(kExternalClearKeyDecryptOnlyKeySystem), 491 Combine(Values(kExternalClearKeyDecryptOnlyKeySystem),
489 Values(MSE), 492 Values(MSE),
490 Values(UNPREFIXED))); 493 Values(UNPREFIXED)));
491 #endif // defined(ENABLE_PEPPER_CDMS) 494 #endif // defined(ENABLE_PEPPER_CDMS)
492 495
493 #if defined(WIDEVINE_CDM_AVAILABLE) 496 #if defined(WIDEVINE_CDM_AVAILABLE)
494 // This test doesn't fully test playback with Widevine. So we only run Widevine 497 // This test doesn't fully test playback with Widevine. So we only run Widevine
495 // test with MSE (no SRC) to reduce test time. Also, on Android EME only works 498 // test with MSE (no SRC) to reduce test time. Also, on Android EME only works
496 // with MSE and we cannot run this test with SRC. 499 // with MSE and we cannot run this test with SRC.
497 INSTANTIATE_TEST_CASE_P(MSE_Widevine_Prefixed, 500 INSTANTIATE_TEST_CASE_P(MSE_Widevine_Prefixed,
498 EncryptedMediaTest, 501 EncryptedMediaTest,
499 Combine(Values(kWidevineKeySystem), 502 Combine(Values(kWidevineKeySystem),
500 Values(MSE), 503 Values(MSE),
501 Values(PREFIXED))); 504 Values(PREFIXED)));
502 505
503 // Following tests fail if Widevine is loaded as a component, crbug.com/356833. 506 // Following tests fail if Widevine is loaded as a component, crbug.com/356833.
504 #if !defined(WIDEVINE_CDM_IS_COMPONENT) 507 #if !defined(WIDEVINE_CDM_IS_COMPONENT)
505 INSTANTIATE_TEST_CASE_P(MSE_Widevine, 508 INSTANTIATE_TEST_CASE_P(MSE_Widevine,
506 EncryptedMediaTest, 509 EncryptedMediaTest,
507 Combine(Values(kWidevineKeySystem), 510 Combine(Values(kWidevineKeySystem),
508 Values(MSE), 511 Values(MSE),
509 Values(UNPREFIXED))); 512 Values(UNPREFIXED)));
510 #endif // !defined(WIDEVINE_CDM_IS_COMPONENT) 513 #endif // !defined(WIDEVINE_CDM_IS_COMPONENT)
511 #endif // defined(WIDEVINE_CDM_AVAILABLE) 514 #endif // defined(WIDEVINE_CDM_AVAILABLE)
512 515
513 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM) { 516 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_WebM) {
514 TestSimplePlayback("bear-a-enc_a.webm", kWebMAudioOnly); 517 TestSimplePlayback("bear-a_enc-a.webm", kWebMAudioOnly);
515 } 518 }
516 519
517 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioClearVideo_WebM) { 520 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioClearVideo_WebM) {
518 TestSimplePlayback("bear-320x240-av-enc_a.webm", kWebMAudioVideo); 521 TestSimplePlayback("bear-320x240-av_enc-a.webm", kWebMAudioVideo);
519 } 522 }
520 523
521 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoAudio_WebM) { 524 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoAudio_WebM) {
522 TestSimplePlayback("bear-320x240-av-enc_av.webm", kWebMAudioVideo); 525 TestSimplePlayback("bear-320x240-av_enc-av.webm", kWebMAudioVideo);
523 } 526 }
524 527
525 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoOnly_WebM) { 528 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoOnly_WebM) {
526 TestSimplePlayback("bear-320x240-v-enc_v.webm", kWebMVideoOnly); 529 TestSimplePlayback("bear-320x240-v_enc-v.webm", kWebMVideoOnly);
527 } 530 }
528 531
529 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoClearAudio_WebM) { 532 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoClearAudio_WebM) {
530 TestSimplePlayback("bear-320x240-av-enc_v.webm", kWebMAudioVideo); 533 TestSimplePlayback("bear-320x240-av_enc-v.webm", kWebMAudioVideo);
531 } 534 }
532 535
533 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VP9Video_WebM) { 536 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VP9Video_WebM) {
534 TestSimplePlayback("bear-320x240-v-vp9-enc_v.webm", kWebMVP9VideoOnly); 537 TestSimplePlayback("bear-320x240-v-vp9_enc-v.webm", kWebMVP9VideoOnly);
535 } 538 }
536 539
537 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, InvalidResponseKeyError) { 540 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, InvalidResponseKeyError) {
538 RunInvalidResponseTest(); 541 RunInvalidResponseTest();
539 } 542 }
540 543
541 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, ConfigChangeVideo) { 544 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, ConfigChangeVideo) {
542 if (CurrentSourceType() != MSE || !IsMSESupported()) { 545 if (CurrentSourceType() != MSE || !IsMSESupported()) {
543 VLOG(0) << "Skipping test - ConfigChange test requires MSE."; 546 VLOG(0) << "Skipping test - ConfigChange test requires MSE.";
544 return; 547 return;
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
580 return; 583 return;
581 } 584 }
582 TestSimplePlayback("bear-640x360-a_frag-cenc.mp4", kMP4AudioOnly); 585 TestSimplePlayback("bear-640x360-a_frag-cenc.mp4", kMP4AudioOnly);
583 } 586 }
584 #endif // defined(USE_PROPRIETARY_CODECS) 587 #endif // defined(USE_PROPRIETARY_CODECS)
585 588
586 #if defined(WIDEVINE_CDM_AVAILABLE) 589 #if defined(WIDEVINE_CDM_AVAILABLE)
587 // The parent key system cannot be used in generateKeyRequest. 590 // The parent key system cannot be used in generateKeyRequest.
588 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException_Prefixed) { 591 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException_Prefixed) {
589 RunEncryptedMediaTest(kDefaultEmePlayer, 592 RunEncryptedMediaTest(kDefaultEmePlayer,
590 "bear-a-enc_a.webm", 593 "bear-a_enc-a.webm",
591 kWebMAudioOnly, 594 kWebMAudioOnly,
592 "com.widevine", 595 "com.widevine",
593 MSE, 596 MSE,
594 PREFIXED, 597 PREFIXED,
595 kNoSessionToLoad, 598 kNoSessionToLoad,
596 false, 599 false,
597 kEmeNotSupportedError); 600 kEmeNotSupportedError);
598 } 601 }
599 602
600 // TODO(jrummell): http://crbug.com/349181 603 // TODO(jrummell): http://crbug.com/349181
601 // The parent key system cannot be used when creating MediaKeys. 604 // The parent key system cannot be used when creating MediaKeys.
602 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException) { 605 IN_PROC_BROWSER_TEST_F(WVEncryptedMediaTest, ParentThrowsException) {
603 RunEncryptedMediaTest(kDefaultEmePlayer, 606 RunEncryptedMediaTest(kDefaultEmePlayer,
604 "bear-a-enc_a.webm", 607 "bear-a_enc-a.webm",
605 kWebMAudioOnly, 608 kWebMAudioOnly,
606 "com.widevine", 609 "com.widevine",
607 MSE, 610 MSE,
608 UNPREFIXED, 611 UNPREFIXED,
609 kNoSessionToLoad, 612 kNoSessionToLoad,
610 false, 613 false,
611 kEmeNotSupportedError); 614 kEmeNotSupportedError);
612 } 615 }
613 #endif // defined(WIDEVINE_CDM_AVAILABLE) 616 #endif // defined(WIDEVINE_CDM_AVAILABLE)
614 617
(...skipping 18 matching lines...) Expand all
633 "plugin crash"); 636 "plugin crash");
634 } 637 }
635 638
636 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, FileIOTest) { 639 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, FileIOTest) {
637 TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem, 640 TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem,
638 kFileIOTestSuccess); 641 kFileIOTestSuccess);
639 } 642 }
640 643
641 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadLoadableSession) { 644 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadLoadableSession) {
642 RunEncryptedMediaTest(kDefaultEmePlayer, 645 RunEncryptedMediaTest(kDefaultEmePlayer,
643 "bear-320x240-v-enc_v.webm", 646 "bear-320x240-v_enc-v.webm",
644 kWebMVideoOnly, 647 kWebMVideoOnly,
645 kExternalClearKeyKeySystem, 648 kExternalClearKeyKeySystem,
646 SRC, 649 SRC,
647 PREFIXED, 650 PREFIXED,
648 kLoadableSession, 651 kLoadableSession,
649 false, 652 false,
650 kEnded); 653 kEnded);
651 } 654 }
652 655
653 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadUnknownSession) { 656 IN_PROC_BROWSER_TEST_F(ECKEncryptedMediaTest, LoadUnknownSession) {
654 // TODO(xhwang): Add a specific error for this failure, e.g. kSessionNotFound. 657 // TODO(xhwang): Add a specific error for this failure, e.g. kSessionNotFound.
655 RunEncryptedMediaTest(kDefaultEmePlayer, 658 RunEncryptedMediaTest(kDefaultEmePlayer,
656 "bear-320x240-v-enc_v.webm", 659 "bear-320x240-v_enc-v.webm",
657 kWebMVideoOnly, 660 kWebMVideoOnly,
658 kExternalClearKeyKeySystem, 661 kExternalClearKeyKeySystem,
659 SRC, 662 SRC,
660 PREFIXED, 663 PREFIXED,
661 kUnknownSession, 664 kUnknownSession,
662 false, 665 false,
663 kEmeKeyError); 666 kEmeKeyError);
664 } 667 }
665 #endif // defined(ENABLE_PEPPER_CDMS) 668 #endif // defined(ENABLE_PEPPER_CDMS)
OLDNEW
« no previous file with comments | « no previous file | chrome/browser/media/encrypted_media_istypesupported_browsertest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698