Extension BaseFeatureProvider minor cleanups. Don't crash in release mode if we failed to parse a p…

chrome/common/extensions/features/base_feature_provider.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/common/extensions/features/base_feature_provider.h"
 
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "chrome/common/extensions/features/complex_feature.h"
 #include "chrome/common/extensions/features/manifest_feature.h"
@@ skipping 23 matching lines @@
   }
 
   scoped_ptr<BaseFeatureProvider> manifest_features;
   scoped_ptr<BaseFeatureProvider> permission_features;
 
  private:
   scoped_ptr<BaseFeatureProvider> LoadProvider(
       const std::string& debug_string,
       BaseFeatureProvider::FeatureFactory factory,
       int resource_id) {
-    std::string manifest_features =
+    const std::string& features_file =
         ResourceBundle::GetSharedInstance().GetRawDataResource(
             resource_id).as_string();
     int error_code = 0;
     std::string error_message;
-    Value* value = base::JSONReader::ReadAndReturnError(
-        manifest_features, base::JSON_PARSE_RFC,
-        &error_code, &error_message);
-    CHECK(value) << "Could not load features: " << debug_string << " "
-                 << error_message;
-    CHECK(value->IsType(Value::TYPE_DICTIONARY)) << debug_string;
-    scoped_ptr<DictionaryValue> dictionary_value(
-        static_cast<DictionaryValue*>(value));
-    return scoped_ptr<BaseFeatureProvider>(
-        new BaseFeatureProvider(*dictionary_value, factory));
+    scoped_ptr<Value> value(base::JSONReader::ReadAndReturnError(
+        features_file, base::JSON_PARSE_RFC,
+        &error_code, &error_message));
+    DCHECK(value) << "Could not load features: " << debug_string << " "
+                  << error_message;
+    scoped_ptr<DictionaryValue> value_as_dict;
+    if (value) {
+      CHECK(value->IsType(Value::TYPE_DICTIONARY)) << debug_string;
+      value_as_dict.reset(static_cast<DictionaryValue*>(value.release()));
+    } else {
+      // http://crbug.com/176381
+      value_as_dict.reset(new DictionaryValue());
+    }
+    return make_scoped_ptr(new BaseFeatureProvider(*value_as_dict, factory));
   }
 };
 
 bool ParseFeature(const DictionaryValue* value,
                   const std::string& name,
                   SimpleFeature* feature) {
-    feature->set_name(name);
-    feature->Parse(value);
+  feature->set_name(name);
+  feature->Parse(value);
 
-    if (feature->extension_types()->empty()) {
-      LOG(ERROR) << name << ": Simple features must specify at least one "
-                 << "value for extension_types.";
-      return false;
-    }
+  if (feature->extension_types()->empty()) {
+    LOG(ERROR) << name << ": Simple features must specify at least one "
+               << "value for extension_types.";
+    return false;
+  }
 
-    if (!feature->GetContexts()->empty()) {
-      LOG(ERROR) << name << ": Simple features do not support contexts.";
-      return false;
-    }
+  if (!feature->GetContexts()->empty()) {
+    LOG(ERROR) << name << ": Simple features do not support contexts.";
+    return false;
+  }
 
-    return true;
+  return true;
 }
 
 base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BaseFeatureProvider::BaseFeatureProvider(const DictionaryValue& root,
-                                             FeatureFactory factory)
+                                         FeatureFactory factory)
     : factory_(factory ? factory :
                static_cast<FeatureFactory>(&CreateFeature<SimpleFeature>)) {
   for (DictionaryValue::Iterator iter(root); iter.HasNext(); iter.Advance()) {
     if (iter.value().GetType() == Value::TYPE_DICTIONARY) {
       linked_ptr<SimpleFeature> feature((*factory_)());
 
       if (!ParseFeature(static_cast<const DictionaryValue*>(&iter.value()),
                         iter.key(),
                         feature.get()))
         continue;
@@ skipping 59 matching lines @@
 
 Feature* BaseFeatureProvider::GetFeature(const std::string& name) {
   FeatureMap::iterator iter = features_.find(name);
   if (iter != features_.end())
     return iter->second.get();
   else
     return NULL;
 }
 
 }  // namespace