Home | History | Annotate | Download | only in extensions 
      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