Home | History | Annotate | Download | only in manifest_handlers 
      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 
     16 namespace keys = extensions::manifest_keys;
     17 namespace errors = extensions::manifest_errors;
     18 
     19 namespace {
     20 
     21 const 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.
     29 struct MimeTypesHandlerInfo : public extensions::Extension::ManifestData {
     30   MimeTypesHandler handler_;
     31 
     32   MimeTypesHandlerInfo();
     33   virtual ~MimeTypesHandlerInfo();
     34 };
     35 
     36 MimeTypesHandlerInfo::MimeTypesHandlerInfo() {
     37 }
     38 
     39 MimeTypesHandlerInfo::~MimeTypesHandlerInfo() {
     40 }
     41 
     42 }  // namespace
     43 
     44 // static
     45 std::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 
     52 MimeTypesHandler::MimeTypesHandler() {
     53 }
     54 
     55 MimeTypesHandler::~MimeTypesHandler() {
     56 }
     57 
     58 void MimeTypesHandler::AddMIMEType(const std::string& mime_type) {
     59   mime_type_set_.insert(mime_type);
     60 }
     61 
     62 bool MimeTypesHandler::CanHandleMIMEType(const std::string& mime_type) const {
     63   return mime_type_set_.find(mime_type) != mime_type_set_.end();
     64 }
     65 
     66 // static
     67 MimeTypesHandler* 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 
     76 MimeTypesHandlerParser::MimeTypesHandlerParser() {
     77 }
     78 
     79 MimeTypesHandlerParser::~MimeTypesHandlerParser() {
     80 }
     81 
     82 bool 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 
    112 const 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