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
|
// 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 "chrome/common/extensions/api/file_handlers/file_handlers_parser.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/utf_string_conversions.h"
#include "base/values.h"
#include "chrome/common/extensions/extension_manifest_constants.h"
#include "chrome/common/extensions/manifest.h"
#include "extensions/common/error_utils.h"
namespace extensions {
FileHandlerInfo::FileHandlerInfo() {}
FileHandlerInfo::~FileHandlerInfo() {}
FileHandlers::FileHandlers() {}
FileHandlers::~FileHandlers() {}
// static
const std::vector<FileHandlerInfo>* FileHandlers::GetFileHandlers(
const Extension* extension) {
FileHandlers* info = static_cast<FileHandlers*>(
extension->GetManifestData(extension_manifest_keys::kFileHandlers));
return info ? &info->file_handlers : NULL;
}
FileHandlersParser::FileHandlersParser() {
}
FileHandlersParser::~FileHandlersParser() {
}
bool LoadFileHandler(const std::string& handler_id,
const DictionaryValue& handler_info,
std::vector<FileHandlerInfo>* file_handlers,
string16* error) {
DCHECK(error);
FileHandlerInfo handler;
handler.id = handler_id;
const ListValue* mime_types = NULL;
// TODO(benwells): handle file extensions.
if (!handler_info.HasKey(extension_manifest_keys::kFileHandlerTypes) ||
!handler_info.GetList(extension_manifest_keys::kFileHandlerTypes,
&mime_types) || mime_types->GetSize() == 0) {
*error = ErrorUtils::FormatErrorMessageUTF16(
extension_manifest_errors::kInvalidFileHandlerType, handler_id);
return false;
}
if (handler_info.HasKey(extension_manifest_keys::kFileHandlerTitle) &&
!handler_info.GetString(extension_manifest_keys::kFileHandlerTitle,
&handler.title)) {
*error = ASCIIToUTF16(extension_manifest_errors::kInvalidFileHandlerTitle);
return false;
}
std::string type;
for (size_t i = 0; i < mime_types->GetSize(); ++i) {
if (!mime_types->GetString(i, &type)) {
*error = ErrorUtils::FormatErrorMessageUTF16(
extension_manifest_errors::kInvalidFileHandlerTypeElement, handler_id,
std::string(base::IntToString(i)));
return false;
}
handler.types.insert(type);
}
file_handlers->push_back(handler);
return true;
}
bool FileHandlersParser::Parse(Extension* extension, string16* error) {
scoped_ptr<FileHandlers> info(new FileHandlers);
const DictionaryValue* all_handlers = NULL;
if (!extension->manifest()->GetDictionary(
extension_manifest_keys::kFileHandlers, &all_handlers)) {
*error = ASCIIToUTF16(extension_manifest_errors::kInvalidFileHandlers);
return false;
}
DCHECK(extension->is_platform_app());
for (DictionaryValue::key_iterator iter(all_handlers->begin_keys());
iter != all_handlers->end_keys(); ++iter) {
// A file handler entry is a title and a list of MIME types to handle.
const DictionaryValue* handler = NULL;
if (all_handlers->GetDictionaryWithoutPathExpansion(*iter, &handler)) {
if (!LoadFileHandler(*iter, *handler, &info->file_handlers, error))
return false;
} else {
*error = ASCIIToUTF16(extension_manifest_errors::kInvalidFileHandlers);
return false;
}
}
extension->SetManifestData(extension_manifest_keys::kFileHandlers,
info.release());
return true;
}
} // namespace extensions
|
