detect preferences errors

chrome/common/extensions/extension_unittest.cc

 // Copyright (c) 2010 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/extension.h"
 
 #include "base/format_macros.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
@@ skipping 32 matching lines @@
 // Bug: http://crbug.com/38462
 
 
 TEST(ExtensionTest, InitFromValueInvalid) {
 #if defined(OS_WIN)
   FilePath path(FILE_PATH_LITERAL("c:\\foo"));
 #elif defined(OS_POSIX)
   FilePath path(FILE_PATH_LITERAL("/foo"));
 #endif
   Extension extension(path);
+  int error_code = 0;
   std::string error;
   ExtensionErrorReporter::Init(false);
 
   // Start with a valid extension manifest
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0")
       .Append(Extension::kManifestFilename);
 
   JSONFileValueSerializer serializer(extensions_path);
   scoped_ptr<DictionaryValue> valid_value(
-      static_cast<DictionaryValue*>(serializer.Deserialize(&error)));
+      static_cast<DictionaryValue*>(serializer.Deserialize(&error_code,
+                                                           &error)));
   EXPECT_EQ("", error);
+  EXPECT_EQ(0, error_code);
   ASSERT_TRUE(valid_value.get());
   ASSERT_TRUE(extension.InitFromValue(*valid_value, true, &error));
   ASSERT_EQ("", error);
   EXPECT_EQ("en_US", extension.default_locale());
 
   scoped_ptr<DictionaryValue> input_value;
 
   // Test missing and invalid versions
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
   input_value->Remove(keys::kVersion, NULL);
@@ skipping 567 matching lines @@
 
 static Extension* LoadManifest(const std::string& dir,
                                const std::string& test_file) {
   FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   path = path.AppendASCII("extensions")
              .AppendASCII(dir)
              .AppendASCII(test_file);
 
   JSONFileValueSerializer serializer(path);
-  scoped_ptr<Value> result(serializer.Deserialize(NULL));
+  scoped_ptr<Value> result(serializer.Deserialize(NULL, NULL));
   if (!result.get())
     return NULL;
 
   std::string error;
   scoped_ptr<Extension> extension(new Extension(path.DirName()));
   extension->InitFromValue(*static_cast<DictionaryValue*>(result.get()),
                            false, &error);
 
   return extension.release();
 }
@@ skipping 112 matching lines @@
     scoped_ptr<Extension> new_extension(
         LoadManifest("allow_silent_upgrade",
                      std::string(kTests[i].base_name) + "_new.json"));
 
     EXPECT_EQ(kTests[i].expect_success,
               Extension::IsPrivilegeIncrease(old_extension.get(),
                                              new_extension.get()))
         << kTests[i].base_name;
   }
 }