Home | History | Annotate | Download | only in features 
      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/features/base_feature_provider.h"
      6 
      7 #include <stack>
      8 #include <utility>
      9 
     10 #include "base/strings/string_split.h"
     11 #include "base/strings/string_util.h"
     12 #include "extensions/common/extensions_client.h"
     13 #include "extensions/common/features/complex_feature.h"
     14 #include "extensions/common/features/simple_feature.h"
     15 
     16 namespace extensions {
     17 
     18 namespace {
     19 
     20 bool ParseFeature(const base::DictionaryValue* value,
     21                   const std::string& name,
     22                   SimpleFeature* feature) {
     23   feature->set_name(name);
     24   std::string error = feature->Parse(value);
     25   if (!error.empty())
     26     LOG(ERROR) << error;
     27   return error.empty();
     28 }
     29 
     30 }  // namespace
     31 
     32 BaseFeatureProvider::BaseFeatureProvider(const base::DictionaryValue& root,
     33                                          FeatureFactory factory)
     34     : factory_(factory) {
     35   for (base::DictionaryValue::Iterator iter(root); !iter.IsAtEnd();
     36        iter.Advance()) {
     37     if (iter.value().GetType() == base::Value::TYPE_DICTIONARY) {
     38       linked_ptr<SimpleFeature> feature((*factory_)());
     39 
     40       std::vector<std::string> split;
     41       base::SplitString(iter.key(), '.', &split);
     42 
     43       // Push parent features on the stack, starting with the current feature.
     44       // If one of the features has "noparent" set, stop pushing features on
     45       // the stack. The features will then be parsed in order, starting with
     46       // the farthest parent that is either top level or has "noparent" set.
     47       std::stack<std::pair<std::string, const base::DictionaryValue*> >
     48           parse_stack;
     49       while (!split.empty()) {
     50         std::string parent_name = JoinString(split, '.');
     51         split.pop_back();
     52         if (root.HasKey(parent_name)) {
     53           const base::DictionaryValue* parent = NULL;
     54           CHECK(root.GetDictionaryWithoutPathExpansion(parent_name, &parent));
     55           parse_stack.push(std::make_pair(parent_name, parent));
     56           bool no_parent = false;
     57           parent->GetBoolean("noparent", &no_parent);
     58           if (no_parent)
     59             break;
     60         }
     61       }
     62 
     63       CHECK(!parse_stack.empty());
     64       // Parse all parent features.
     65       bool parse_error = false;
     66       while (!parse_stack.empty()) {
     67         if (!ParseFeature(parse_stack.top().second,
     68                           parse_stack.top().first,
     69                           feature.get())) {
     70           parse_error = true;
     71           break;
     72         }
     73         parse_stack.pop();
     74       }
     75 
     76       if (parse_error)
     77         continue;
     78 
     79       features_[iter.key()] = feature;
     80     } else if (iter.value().GetType() == base::Value::TYPE_LIST) {
     81       // This is a complex feature.
     82       const base::ListValue* list =
     83           static_cast<const base::ListValue*>(&iter.value());
     84       CHECK_GT(list->GetSize(), 0UL);
     85 
     86       scoped_ptr<ComplexFeature::FeatureList> features(
     87           new ComplexFeature::FeatureList());
     88 
     89       // Parse and add all SimpleFeatures from the list.
     90       for (base::ListValue::const_iterator list_iter = list->begin();
     91            list_iter != list->end(); ++list_iter) {
     92         if ((*list_iter)->GetType() != base::Value::TYPE_DICTIONARY) {
     93           LOG(ERROR) << iter.key() << ": Feature rules must be dictionaries.";
     94           continue;
     95         }
     96 
     97         scoped_ptr<SimpleFeature> feature((*factory_)());
     98         if (!ParseFeature(static_cast<const base::DictionaryValue*>(*list_iter),
     99                           iter.key(),
    100                           feature.get()))
    101           continue;
    102 
    103         features->push_back(feature.release());
    104       }
    105 
    106       linked_ptr<ComplexFeature> feature(new ComplexFeature(features.Pass()));
    107       feature->set_name(iter.key());
    108 
    109       features_[iter.key()] = feature;
    110     } else {
    111       LOG(ERROR) << iter.key() << ": Feature description must be dictionary or"
    112                  << " list of dictionaries.";
    113     }
    114   }
    115 }
    116 
    117 BaseFeatureProvider::~BaseFeatureProvider() {
    118 }
    119 
    120 const std::vector<std::string>& BaseFeatureProvider::GetAllFeatureNames()
    121     const {
    122   if (feature_names_.empty()) {
    123     for (FeatureMap::const_iterator iter = features_.begin();
    124          iter != features_.end(); ++iter) {
    125       feature_names_.push_back(iter->first);
    126     }
    127     // A std::map is sorted by its keys, so we don't need to sort feature_names_
    128     // now.
    129   }
    130   return feature_names_;
    131 }
    132 
    133 Feature* BaseFeatureProvider::GetFeature(const std::string& name) const {
    134   FeatureMap::const_iterator iter = features_.find(name);
    135   if (iter != features_.end())
    136     return iter->second.get();
    137   else
    138     return NULL;
    139 }
    140 
    141 Feature* BaseFeatureProvider::GetParent(Feature* feature) const {
    142   CHECK(feature);
    143   if (feature->no_parent())
    144     return NULL;
    145 
    146   std::vector<std::string> split;
    147   base::SplitString(feature->name(), '.', &split);
    148   if (split.size() < 2)
    149     return NULL;
    150   split.pop_back();
    151   return GetFeature(JoinString(split, '.'));
    152 }
    153 
    154 // Children of a given API are named starting with parent.name()+".", which
    155 // means they'll be contiguous in the features_ std::map.
    156 std::vector<Feature*> BaseFeatureProvider::GetChildren(const Feature& parent)
    157     const {
    158   std::string prefix = parent.name() + ".";
    159   const FeatureMap::const_iterator first_child = features_.lower_bound(prefix);
    160 
    161   // All children have names before (parent.name() + ('.'+1)).
    162   ++prefix[prefix.size() - 1];
    163   const FeatureMap::const_iterator after_children =
    164       features_.lower_bound(prefix);
    165 
    166   std::vector<Feature*> result;
    167   result.reserve(std::distance(first_child, after_children));
    168   for (FeatureMap::const_iterator it = first_child; it != after_children;
    169        ++it) {
    170     result.push_back(it->second.get());
    171   }
    172   return result;
    173 }
    174 
    175 }  // namespace extensions
    176