chrome/common/extensions/api/managed_mode_private/managed_mode_handler.cc

   1 // Copyright (c) 2013 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/api/managed_mode_private/managed_mode_handler.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/values.h"
  11 #include "extensions/common/error_utils.h"
  12 #include "extensions/common/manifest_constants.h"
  13
  14 namespace extensions {
  15
  16 namespace keys = manifest_keys;
  17
  18 ManagedModeInfo::ManagedModeInfo() {
  19 }
  20
  21 ManagedModeInfo::~ManagedModeInfo() {
  22 }
  23
  24 // static
  25 bool ManagedModeInfo::IsContentPack(const Extension* extension) {
  26   ManagedModeInfo* info = static_cast<ManagedModeInfo*>(
  27       extension->GetManifestData(keys::kContentPack));
  28   return info ? !info->site_list.empty() : false;
  29 }
  30
  31 // static
  32 ExtensionResource ManagedModeInfo::GetContentPackSiteList(
  33     const Extension* extension) {
  34   ManagedModeInfo* info = static_cast<ManagedModeInfo*>(
  35     extension->GetManifestData(keys::kContentPack));
  36   return info && !info->site_list.empty() ?
  37       extension->GetResource(info->site_list) :
  38       ExtensionResource();
  39 }
  40
  41 ManagedModeHandler::ManagedModeHandler() {
  42 }
  43
  44 ManagedModeHandler::~ManagedModeHandler() {
  45 }
  46
  47 bool ManagedModeHandler::Parse(Extension* extension, base::string16* error) {
  48   if (!extension->manifest()->HasKey(keys::kContentPack))
  49     return true;
  50
  51   scoped_ptr<ManagedModeInfo> info(new ManagedModeInfo);
  52   const base::DictionaryValue* content_pack_value = NULL;
  53   if (!extension->manifest()->GetDictionary(keys::kContentPack,
  54                                             &content_pack_value)) {
  55     *error = base::ASCIIToUTF16(manifest_errors::kInvalidContentPack);
  56     return false;
  57   }
  58
  59   if (!LoadSites(info.get(), content_pack_value, error) ||
  60       !LoadConfigurations(info.get(), content_pack_value, error)) {
  61     return false;
  62   }
  63
  64   extension->SetManifestData(keys::kContentPack, info.release());
  65   return true;
  66 }
  67
  68 const std::vector<std::string> ManagedModeHandler::Keys() const {
  69   return SingleKey(keys::kContentPack);
  70 }
  71
  72 bool ManagedModeHandler::LoadSites(
  73     ManagedModeInfo* info,
  74     const base::DictionaryValue* content_pack_value,
  75     base::string16* error) {
  76   if (!content_pack_value->HasKey(keys::kContentPackSites))
  77     return true;
  78
  79   base::FilePath::StringType site_list_string;
  80   if (!content_pack_value->GetString(keys::kContentPackSites,
  81                                      &site_list_string)) {
  82     *error = base::ASCIIToUTF16(manifest_errors::kInvalidContentPackSites);
  83     return false;
  84   }
  85
  86   info->site_list = base::FilePath(site_list_string);
  87
  88   return true;
  89 }
  90
  91 bool ManagedModeHandler::LoadConfigurations(
  92     ManagedModeInfo* info,
  93     const base::DictionaryValue* content_pack_value,
  94     base::string16* error) {
  95   NOTIMPLEMENTED();
  96   return true;
  97 }
  98
  99 }  // namespace extensions