Move system.display tests to extensions/

chrome/browser/extensions/extension_function_test_utils.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/browser/extensions/extension_function_test_utils.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
@@ skipping 42 matching lines @@
 
 base::ListValue* ParseList(const std::string& data) {
   base::Value* result = ParseJSON(data);
   base::ListValue* list = NULL;
   result->GetAsList(&list);
   return list;
 }
 
 base::DictionaryValue* ParseDictionary(
     const std::string& data) {
-  base::Value* result = ParseJSON(data);
-  base::DictionaryValue* dict = NULL;
-  result->GetAsDictionary(&dict);
-  return dict;
+  return extensions::api_test_utils::ParseDictionary(data);
 }
 
 bool GetBoolean(const base::DictionaryValue* val, const std::string& key) {
-  bool result = false;
-  if (!val->GetBoolean(key, &result))
-      ADD_FAILURE() << key << " does not exist or is not a boolean.";
-  return result;
+  return extensions::api_test_utils::GetBoolean(val, key);
 }
 
 int GetInteger(const base::DictionaryValue* val, const std::string& key) {
-  int result = 0;
-  if (!val->GetInteger(key, &result))
-    ADD_FAILURE() << key << " does not exist or is not an integer.";
-  return result;
+  return extensions::api_test_utils::GetInteger(val, key);
 }
 
 std::string GetString(const base::DictionaryValue* val,
                       const std::string& key) {
-  std::string result;
-  if (!val->GetString(key, &result))
-    ADD_FAILURE() << key << " does not exist or is not a string.";
-  return result;
+  return extensions::api_test_utils::GetString(val, key);
 }
 
 base::DictionaryValue* ToDictionary(base::Value* val) {
   EXPECT_TRUE(val);
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, val->GetType());
   return static_cast<base::DictionaryValue*>(val);
 }
 
 base::ListValue* ToList(base::Value* val) {
   EXPECT_TRUE(val);
   EXPECT_EQ(base::Value::TYPE_LIST, val->GetType());
   return static_cast<base::ListValue*>(val);
 }
 
 scoped_refptr<Extension> CreateEmptyExtensionWithLocation(
     Manifest::Location location) {
   scoped_ptr<base::DictionaryValue> test_extension_value(
       ParseDictionary("{\"name\": \"Test\", \"version\": \"1.0\"}"));
-  return CreateExtension(location, test_extension_value.get(), std::string());
+  return extensions::api_test_utils::CreateExtension(
+      location, test_extension_value.get(), std::string());
 }
 
 scoped_refptr<Extension> CreateExtension(
     base::DictionaryValue* test_extension_value) {
-  return CreateExtension(Manifest::INTERNAL, test_extension_value,
-                         std::string());
+  return extensions::api_test_utils::CreateExtension(
+      Manifest::INTERNAL, test_extension_value, std::string());
 }
 
 scoped_refptr<Extension> CreateExtension(
     Manifest::Location location,
     base::DictionaryValue* test_extension_value,
     const std::string& id_input) {
-  std::string error;
-  const base::FilePath test_extension_path;
-  std::string id;
-  if (!id_input.empty())
-    id = crx_file::id_util::GenerateId(id_input);
-  scoped_refptr<Extension> extension(Extension::Create(
-      test_extension_path,
-      location,
-      *test_extension_value,
-      Extension::NO_FLAGS,
-      id,
-      &error));
-  EXPECT_TRUE(error.empty()) << "Could not parse test extension " << error;
-  return extension;
+  return extensions::api_test_utils::CreateExtension(
+      location, test_extension_value, id_input);
 }
 
 bool HasPrivacySensitiveFields(base::DictionaryValue* val) {
   std::string result;
   if (val->GetString(keys::kUrlKey, &result) ||
       val->GetString(keys::kTitleKey, &result) ||
       val->GetString(keys::kFaviconUrlKey, &result))
     return true;
   return false;
 }
@@ skipping 101 matching lines @@
   // only one place.  See crbug.com/394840.
   return extensions::api_test_utils::RunFunction(
       function,
       args.Pass(),
       browser->profile(),
       dispatcher.Pass(),
       static_cast<extensions::api_test_utils::RunFunctionFlags>(flags));
 }
 
 } // namespace extension_function_test_utils