1 // Copyright (c) 2012 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/mime_types_handler.h" 6 7 #include "base/logging.h" 8 #include "base/strings/string_number_conversions.h" 9 #include "base/strings/string_util.h" 10 #include "base/strings/utf_string_conversions.h" 11 #include "base/values.h" 12 #include "chrome/common/extensions/extension_constants.h" 13 #include "chrome/common/extensions/extension_manifest_constants.h" 14 #include "chrome/common/extensions/manifest.h" 15 #include "content/public/common/url_constants.h" 16 #include "extensions/common/error_utils.h" 17 #include "extensions/common/url_pattern.h" 18 #include "url/gurl.h" 19 #include "url/url_util.h" 20 21 namespace keys = extension_manifest_keys; 22 namespace errors = extension_manifest_errors; 23 24 namespace { 25 26 const char* const kMIMETypeHandlersWhitelist[] = { 27 extension_misc::kQuickOfficeComponentExtensionId, 28 extension_misc::kQuickOfficeDevExtensionId, 29 extension_misc::kQuickOfficeExtensionId, 30 extension_misc::kStreamsPrivateTestExtensionId 31 }; 32 33 // Stored on the Extension. 34 struct MimeTypesHandlerInfo : public extensions::Extension::ManifestData { 35 MimeTypesHandler handler_; 36 37 MimeTypesHandlerInfo(); 38 virtual ~MimeTypesHandlerInfo(); 39 }; 40 41 MimeTypesHandlerInfo::MimeTypesHandlerInfo() { 42 } 43 44 MimeTypesHandlerInfo::~MimeTypesHandlerInfo() { 45 } 46 47 } // namespace 48 49 // static 50 std::vector<std::string> MimeTypesHandler::GetMIMETypeWhitelist() { 51 std::vector<std::string> whitelist; 52 for (size_t i = 0; i < arraysize(kMIMETypeHandlersWhitelist); ++i) 53 whitelist.push_back(kMIMETypeHandlersWhitelist[i]); 54 return whitelist; 55 } 56 57 MimeTypesHandler::MimeTypesHandler() { 58 } 59 60 MimeTypesHandler::~MimeTypesHandler() { 61 } 62 63 void MimeTypesHandler::AddMIMEType(const std::string& mime_type) { 64 mime_type_set_.insert(mime_type); 65 } 66 67 bool MimeTypesHandler::CanHandleMIMEType(const std::string& mime_type) const { 68 return mime_type_set_.find(mime_type) != mime_type_set_.end(); 69 } 70 71 // static 72 MimeTypesHandler* MimeTypesHandler::GetHandler( 73 const extensions::Extension* extension) { 74 MimeTypesHandlerInfo* info = static_cast<MimeTypesHandlerInfo*>( 75 extension->GetManifestData(keys::kMimeTypesHandler)); 76 if (info) 77 return &info->handler_; 78 return NULL; 79 } 80 81 MimeTypesHandlerParser::MimeTypesHandlerParser() { 82 } 83 84 MimeTypesHandlerParser::~MimeTypesHandlerParser() { 85 } 86 87 bool MimeTypesHandlerParser::Parse(extensions::Extension* extension, 88 string16* error) { 89 const base::ListValue* mime_types_value = NULL; 90 if (!extension->manifest()->GetList(keys::kMIMETypes, 91 &mime_types_value)) { 92 *error = ASCIIToUTF16(errors::kInvalidMimeTypesHandler); 93 return false; 94 } 95 96 scoped_ptr<MimeTypesHandlerInfo> info(new MimeTypesHandlerInfo); 97 info->handler_.set_extension_id(extension->id()); 98 for (size_t i = 0; i < mime_types_value->GetSize(); ++i) { 99 std::string filter; 100 if (!mime_types_value->GetString(i, &filter)) { 101 *error = ASCIIToUTF16(errors::kInvalidMIMETypes); 102 return false; 103 } 104 info->handler_.AddMIMEType(filter); 105 } 106 107 extension->SetManifestData(keys::kMimeTypesHandler, info.release()); 108 return true; 109 } 110 111 const std::vector<std::string> MimeTypesHandlerParser::Keys() const { 112 return SingleKey(keys::kMIMETypes); 113 } 114