1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/common/extensions/manifest_handlers/mime_types_handler.h"
6
7#include "base/logging.h"
8#include "base/strings/string_util.h"
9#include "base/strings/utf_string_conversions.h"
10#include "base/values.h"
11#include "chrome/common/extensions/extension_constants.h"
12#include "extensions/common/error_utils.h"
13#include "extensions/common/manifest.h"
14#include "extensions/common/manifest_constants.h"
15
16namespace keys = extensions::manifest_keys;
17namespace errors = extensions::manifest_errors;
18
19namespace {
20
21const char* const kMIMETypeHandlersWhitelist[] = {
22    extension_misc::kPdfExtensionId,
23    extension_misc::kQuickOfficeComponentExtensionId,
24    extension_misc::kQuickOfficeInternalExtensionId,
25    extension_misc::kQuickOfficeExtensionId,
26    extension_misc::kStreamsPrivateTestExtensionId};
27
28// Stored on the Extension.
29struct MimeTypesHandlerInfo : public extensions::Extension::ManifestData {
30  MimeTypesHandler handler_;
31
32  MimeTypesHandlerInfo();
33  virtual ~MimeTypesHandlerInfo();
34};
35
36MimeTypesHandlerInfo::MimeTypesHandlerInfo() {
37}
38
39MimeTypesHandlerInfo::~MimeTypesHandlerInfo() {
40}
41
42}  // namespace
43
44// static
45std::vector<std::string> MimeTypesHandler::GetMIMETypeWhitelist() {
46  std::vector<std::string> whitelist;
47  for (size_t i = 0; i < arraysize(kMIMETypeHandlersWhitelist); ++i)
48    whitelist.push_back(kMIMETypeHandlersWhitelist[i]);
49  return whitelist;
50}
51
52MimeTypesHandler::MimeTypesHandler() {
53}
54
55MimeTypesHandler::~MimeTypesHandler() {
56}
57
58void MimeTypesHandler::AddMIMEType(const std::string& mime_type) {
59  mime_type_set_.insert(mime_type);
60}
61
62bool MimeTypesHandler::CanHandleMIMEType(const std::string& mime_type) const {
63  return mime_type_set_.find(mime_type) != mime_type_set_.end();
64}
65
66// static
67MimeTypesHandler* MimeTypesHandler::GetHandler(
68    const extensions::Extension* extension) {
69  MimeTypesHandlerInfo* info = static_cast<MimeTypesHandlerInfo*>(
70      extension->GetManifestData(keys::kMimeTypesHandler));
71  if (info)
72    return &info->handler_;
73  return NULL;
74}
75
76MimeTypesHandlerParser::MimeTypesHandlerParser() {
77}
78
79MimeTypesHandlerParser::~MimeTypesHandlerParser() {
80}
81
82bool MimeTypesHandlerParser::Parse(extensions::Extension* extension,
83                                   base::string16* error) {
84  const base::ListValue* mime_types_value = NULL;
85  if (!extension->manifest()->GetList(keys::kMIMETypes,
86                                      &mime_types_value)) {
87    *error = base::ASCIIToUTF16(errors::kInvalidMimeTypesHandler);
88    return false;
89  }
90
91  scoped_ptr<MimeTypesHandlerInfo> info(new MimeTypesHandlerInfo);
92  info->handler_.set_extension_id(extension->id());
93  for (size_t i = 0; i < mime_types_value->GetSize(); ++i) {
94    std::string filter;
95    if (!mime_types_value->GetString(i, &filter)) {
96      *error = base::ASCIIToUTF16(errors::kInvalidMIMETypes);
97      return false;
98    }
99    info->handler_.AddMIMEType(filter);
100  }
101
102  std::string mime_types_handler;
103  if (extension->manifest()->GetString(keys::kMimeTypesHandler,
104                                       &mime_types_handler)) {
105    info->handler_.set_handler_url(mime_types_handler);
106  }
107
108  extension->SetManifestData(keys::kMimeTypesHandler, info.release());
109  return true;
110}
111
112const std::vector<std::string> MimeTypesHandlerParser::Keys() const {
113  std::vector<std::string> keys;
114  keys.push_back(keys::kMIMETypes);
115  keys.push_back(keys::kMimeTypesHandler);
116  return keys;
117}
118