extensions/common/extension_set.cc

   1 // Copyright 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 "extensions/common/extension_set.h"
   6
   7 #include "base/callback.h"
   8 #include "base/logging.h"
   9 #include "base/stl_util.h"
  10 #include "extensions/common/constants.h"
  11 #include "extensions/common/extension.h"
  12 #include "extensions/common/manifest_handlers/sandboxed_page_info.h"
  13
  14 namespace extensions {
  15
  16 ExtensionSet::const_iterator::const_iterator() {}
  17
  18 ExtensionSet::const_iterator::const_iterator(const const_iterator& other)
  19     : it_(other.it_) {
  20 }
  21
  22 ExtensionSet::const_iterator::const_iterator(ExtensionMap::const_iterator it)
  23     : it_(it) {
  24 }
  25
  26 ExtensionSet::const_iterator::~const_iterator() {}
  27
  28 ExtensionSet::ExtensionSet() {
  29 }
  30
  31 ExtensionSet::~ExtensionSet() {
  32 }
  33
  34 size_t ExtensionSet::size() const {
  35   return extensions_.size();
  36 }
  37
  38 bool ExtensionSet::is_empty() const {
  39   return extensions_.empty();
  40 }
  41
  42 bool ExtensionSet::Contains(const std::string& extension_id) const {
  43   return extensions_.find(extension_id) != extensions_.end();
  44 }
  45
  46 bool ExtensionSet::Insert(const scoped_refptr<const Extension>& extension) {
  47   bool was_present = ContainsKey(extensions_, extension->id());
  48   extensions_[extension->id()] = extension;
  49   if (!was_present && !modification_callback_.is_null())
  50     modification_callback_.Run(GetIDs());
  51   return !was_present;
  52 }
  53
  54 bool ExtensionSet::InsertAll(const ExtensionSet& extensions) {
  55   size_t before = size();
  56   for (ExtensionSet::const_iterator iter = extensions.begin();
  57        iter != extensions.end(); ++iter) {
  58     Insert(*iter);
  59   }
  60   return size() != before;
  61 }
  62
  63 bool ExtensionSet::Remove(const std::string& id) {
  64   bool was_present = extensions_.erase(id) > 0;
  65   if (was_present && !modification_callback_.is_null())
  66     modification_callback_.Run(GetIDs());
  67   return was_present;
  68 }
  69
  70 void ExtensionSet::Clear() {
  71   extensions_.clear();
  72 }
  73
  74 std::string ExtensionSet::GetExtensionOrAppIDByURL(const GURL& url) const {
  75   if (url.SchemeIs(kExtensionScheme))
  76     return url.host();
  77
  78   const Extension* extension = GetExtensionOrAppByURL(url);
  79   if (!extension)
  80     return std::string();
  81
  82   return extension->id();
  83 }
  84
  85 const Extension* ExtensionSet::GetExtensionOrAppByURL(const GURL& url) const {
  86   if (url.SchemeIs(kExtensionScheme))
  87     return GetByID(url.host());
  88
  89   return GetHostedAppByURL(url);
  90 }
  91
  92 const Extension* ExtensionSet::GetHostedAppByURL(const GURL& url) const {
  93   for (ExtensionMap::const_iterator iter = extensions_.begin();
  94        iter != extensions_.end(); ++iter) {
  95     if (iter->second->web_extent().MatchesURL(url))
  96       return iter->second.get();
  97   }
  98
  99   return NULL;
 100 }
 101
 102 const Extension* ExtensionSet::GetHostedAppByOverlappingWebExtent(
 103     const URLPatternSet& extent) const {
 104   for (ExtensionMap::const_iterator iter = extensions_.begin();
 105        iter != extensions_.end(); ++iter) {
 106     if (iter->second->web_extent().OverlapsWith(extent))
 107       return iter->second.get();
 108   }
 109
 110   return NULL;
 111 }
 112
 113 bool ExtensionSet::InSameExtent(const GURL& old_url,
 114                                 const GURL& new_url) const {
 115   return GetExtensionOrAppByURL(old_url) ==
 116       GetExtensionOrAppByURL(new_url);
 117 }
 118
 119 const Extension* ExtensionSet::GetByID(const std::string& id) const {
 120   ExtensionMap::const_iterator i = extensions_.find(id);
 121   if (i != extensions_.end())
 122     return i->second.get();
 123   else
 124     return NULL;
 125 }
 126
 127 ExtensionIdSet ExtensionSet::GetIDs() const {
 128   ExtensionIdSet ids;
 129   for (ExtensionMap::const_iterator it = extensions_.begin();
 130        it != extensions_.end(); ++it) {
 131     ids.insert(it->first);
 132   }
 133   return ids;
 134 }
 135
 136 bool ExtensionSet::ExtensionBindingsAllowed(const GURL& url) const {
 137   if (url.SchemeIs(kExtensionScheme))
 138     return true;
 139
 140   for (ExtensionMap::const_iterator it = extensions_.begin();
 141        it != extensions_.end(); ++it) {
 142     if (it->second->location() == Manifest::COMPONENT &&
 143         it->second->web_extent().MatchesURL(url))
 144       return true;
 145   }
 146
 147   return false;
 148 }
 149
 150 }  // namespace extensions