1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
// Copyright (c) 2012 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 <map>
#include "webkit/media/crypto/key_systems.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/string_util.h"
#include "net/base/mime_util.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebCString.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
#include "webkit/media/crypto/key_systems_info.h"
namespace webkit_media {
// Convert a WebString to ASCII, falling back on an empty string in the case
// of a non-ASCII string.
static std::string ToASCIIOrEmpty(const WebKit::WebString& string) {
return IsStringASCII(string) ? UTF16ToASCII(string) : std::string();
}
class KeySystems {
public:
bool IsSupportedKeySystem(const std::string& key_system);
bool IsSupportedKeySystemWithMediaMimeType(
const std::string& mime_type,
const std::vector<std::string>& codecs,
const std::string& key_system);
private:
friend struct base::DefaultLazyInstanceTraits<KeySystems>;
typedef base::hash_set<std::string> CodecMappings;
typedef std::map<std::string, CodecMappings> MimeTypeMappings;
typedef std::map<std::string, MimeTypeMappings> KeySystemMappings;
KeySystems();
bool IsSupportedKeySystemWithContainerAndCodec(
const std::string& mime_type,
const std::string& codec,
const std::string& key_system);
KeySystemMappings key_system_map_;
DISALLOW_COPY_AND_ASSIGN(KeySystems);
};
static base::LazyInstance<KeySystems> g_key_systems = LAZY_INSTANCE_INITIALIZER;
KeySystems::KeySystems() {
// Initialize the supported media type/key system combinations.
for (int i = 0; i < kNumSupportedFormatKeySystemCombinations; ++i) {
const MediaFormatAndKeySystem& combination =
kSupportedFormatKeySystemCombinations[i];
std::vector<std::string> mime_type_codecs;
net::ParseCodecString(combination.codecs_list,
&mime_type_codecs,
false);
CodecMappings codecs;
for (size_t j = 0; j < mime_type_codecs.size(); ++j)
codecs.insert(mime_type_codecs[j]);
// Support the MIME type string alone, without codec(s) specified.
codecs.insert("");
// Key systems can be repeated, so there may already be an entry.
KeySystemMappings::iterator key_system_iter =
key_system_map_.find(combination.key_system);
if (key_system_iter == key_system_map_.end()) {
MimeTypeMappings mime_types_map;
mime_types_map[combination.mime_type] = codecs;
key_system_map_[combination.key_system] = mime_types_map;
} else {
MimeTypeMappings& mime_types_map = key_system_iter->second;
// mime_types_map may not be repeated for a given key system.
DCHECK(mime_types_map.find(combination.mime_type) ==
mime_types_map.end());
mime_types_map[combination.mime_type] = codecs;
}
}
}
bool KeySystems::IsSupportedKeySystem(const std::string& key_system) {
bool is_supported = key_system_map_.find(key_system) != key_system_map_.end();
return is_supported && IsSystemCompatible(key_system);
}
bool KeySystems::IsSupportedKeySystemWithContainerAndCodec(
const std::string& mime_type,
const std::string& codec,
const std::string& key_system) {
KeySystemMappings::const_iterator key_system_iter =
key_system_map_.find(key_system);
if (key_system_iter == key_system_map_.end())
return false;
const MimeTypeMappings& mime_types_map = key_system_iter->second;
MimeTypeMappings::const_iterator mime_iter = mime_types_map.find(mime_type);
if (mime_iter == mime_types_map.end())
return false;
const CodecMappings& codecs = mime_iter->second;
return (codecs.find(codec) != codecs.end()) && IsSystemCompatible(key_system);
}
bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
const std::string& mime_type,
const std::vector<std::string>& codecs,
const std::string& key_system) {
if (codecs.empty())
return IsSupportedKeySystemWithContainerAndCodec(mime_type, "", key_system);
for (size_t i = 0; i < codecs.size(); ++i) {
if (!IsSupportedKeySystemWithContainerAndCodec(
mime_type, codecs[i], key_system))
return false;
}
return true;
}
bool IsSupportedKeySystem(const WebKit::WebString& key_system) {
return g_key_systems.Get().IsSupportedKeySystem(ToASCIIOrEmpty(key_system));
}
bool IsSupportedKeySystemWithMediaMimeType(
const std::string& mime_type,
const std::vector<std::string>& codecs,
const std::string& key_system) {
return g_key_systems.Get().IsSupportedKeySystemWithMediaMimeType(
mime_type, codecs, key_system);
}
std::string KeySystemNameForUMA(const std::string& key_system) {
return KeySystemNameForUMAGeneric(key_system);
}
std::string KeySystemNameForUMA(const WebKit::WebString& key_system) {
return KeySystemNameForUMAGeneric(std::string(key_system.utf8().data()));
}
bool CanUseAesDecryptor(const std::string& key_system) {
return CanUseBuiltInAesDecryptor(key_system);
}
std::string GetPluginType(const std::string& key_system) {
for (int i = 0; i < kNumKeySystemToPluginTypeMapping; ++i) {
if (kKeySystemToPluginTypeMapping[i].key_system == key_system)
return kKeySystemToPluginTypeMapping[i].plugin_type;
}
return std::string();
}
} // namespace webkit_media
|
