extensions/common/manifest_handlers/mime_types_handler.cc

   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 "extensions/common/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 "extensions/common/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::kMimeHandlerPrivateTestExtensionId};
  27
  28 // Stored on the Extension.
  29 struct MimeTypesHandlerInfo : public extensions::Extension::ManifestData {
  30   MimeTypesHandler handler_;
  31
  32   MimeTypesHandlerInfo();
  33   ~MimeTypesHandlerInfo() override;
  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 bool MimeTypesHandler::HasPlugin() const {
  67   return !handler_url_.empty();
  68 }
  69
  70 base::FilePath MimeTypesHandler::GetPluginPath() const {
  71   // TODO(raymes): Storing the extension URL in a base::FilePath is really
  72   // nasty. We should probably just use the extension ID as the placeholder path
  73   // instead.
  74   return base::FilePath::FromUTF8Unsafe(
  75       std::string(extensions::kExtensionScheme) + "://" + extension_id_ + "/");
  76 }
  77
  78 // static
  79 MimeTypesHandler* MimeTypesHandler::GetHandler(
  80     const extensions::Extension* extension) {
  81   MimeTypesHandlerInfo* info = static_cast<MimeTypesHandlerInfo*>(
  82       extension->GetManifestData(keys::kMimeTypesHandler));
  83   if (info)
  84     return &info->handler_;
  85   return NULL;
  86 }
  87
  88 MimeTypesHandlerParser::MimeTypesHandlerParser() {
  89 }
  90
  91 MimeTypesHandlerParser::~MimeTypesHandlerParser() {
  92 }
  93
  94 bool MimeTypesHandlerParser::Parse(extensions::Extension* extension,
  95                                    base::string16* error) {
  96   const base::ListValue* mime_types_value = NULL;
  97   if (!extension->manifest()->GetList(keys::kMIMETypes,
  98                                       &mime_types_value)) {
  99     *error = base::ASCIIToUTF16(errors::kInvalidMimeTypesHandler);
 100     return false;
 101   }
 102
 103   scoped_ptr<MimeTypesHandlerInfo> info(new MimeTypesHandlerInfo);
 104   info->handler_.set_extension_id(extension->id());
 105   for (size_t i = 0; i < mime_types_value->GetSize(); ++i) {
 106     std::string filter;
 107     if (!mime_types_value->GetString(i, &filter)) {
 108       *error = base::ASCIIToUTF16(errors::kInvalidMIMETypes);
 109       return false;
 110     }
 111     info->handler_.AddMIMEType(filter);
 112   }
 113
 114   std::string mime_types_handler;
 115   if (extension->manifest()->GetString(keys::kMimeTypesHandler,
 116                                        &mime_types_handler)) {
 117     info->handler_.set_handler_url(mime_types_handler);
 118   }
 119
 120   extension->SetManifestData(keys::kMimeTypesHandler, info.release());
 121   return true;
 122 }
 123
 124 const std::vector<std::string> MimeTypesHandlerParser::Keys() const {
 125   std::vector<std::string> keys;
 126   keys.push_back(keys::kMIMETypes);
 127   keys.push_back(keys::kMimeTypesHandler);
 128   return keys;
 129 }