Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2012 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 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_TEST_UTILS_H_
      6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_TEST_UTILS_H_
      7 
      8 #include <string>
      9 
     10 #include "base/memory/ref_counted.h"
     11 #include "extensions/common/manifest.h"
     12 
     13 class AsyncExtensionFunction;
     14 class Browser;
     15 class UIThreadExtensionFunction;
     16 
     17 namespace base {
     18 class Value;
     19 class DictionaryValue;
     20 class ListValue;
     21 }
     22 
     23 namespace extensions {
     24 class Extension;
     25 }
     26 
     27 namespace extension_function_test_utils {
     28 
     29 // Parse JSON and return as the specified type, or NULL if the JSON is invalid
     30 // or not the specified type.
     31 base::Value* ParseJSON(const std::string& data);
     32 base::ListValue* ParseList(const std::string& data);
     33 base::DictionaryValue* ParseDictionary(const std::string& data);
     34 
     35 // Get |key| from |val| as the specified type. If |key| does not exist, or is
     36 // not of the specified type, adds a failure to the current test and returns
     37 // false, 0, empty string, etc.
     38 bool GetBoolean(base::DictionaryValue* val, const std::string& key);
     39 int GetInteger(base::DictionaryValue* val, const std::string& key);
     40 std::string GetString(base::DictionaryValue* val, const std::string& key);
     41 
     42 // If |val| is a dictionary, return it as one, otherwise NULL.
     43 base::DictionaryValue* ToDictionary(base::Value* val);
     44 
     45 // If |val| is a list, return it as one, otherwise NULL.
     46 base::ListValue* ToList(base::Value* val);
     47 
     48 // Creates an extension instance that can be attached to an ExtensionFunction
     49 // before running it.
     50 scoped_refptr<extensions::Extension> CreateEmptyExtension();
     51 
     52 // Creates an extension instance with a specified location that can be attached
     53 // to an ExtensionFunction before running.
     54 scoped_refptr<extensions::Extension> CreateEmptyExtensionWithLocation(
     55     extensions::Manifest::Location location);
     56 
     57 // Creates an empty extension with a variable ID, for tests that require
     58 // multiple extensions side-by-side having distinct IDs. If not empty, then
     59 // id_input is passed directly to Extension::CreateId() and thus has the same
     60 // behavior as that method. If id_input is empty, then Extension::Create()
     61 // receives an empty explicit ID and generates an appropriate ID for a blank
     62 // extension.
     63 scoped_refptr<extensions::Extension> CreateEmptyExtension(
     64     const std::string& id_input);
     65 
     66 scoped_refptr<extensions::Extension> CreateExtension(
     67     extensions::Manifest::Location location,
     68     base::DictionaryValue* test_extension_value,
     69     const std::string& id_input);
     70 
     71 // Creates an extension instance with a specified extension value that can be
     72 // attached to an ExtensionFunction before running.
     73 scoped_refptr<extensions::Extension> CreateExtension(
     74     base::DictionaryValue* test_extension_value);
     75 
     76 // Returns true if |val| contains privacy information, e.g. url,
     77 // title, and faviconUrl.
     78 bool HasPrivacySensitiveFields(base::DictionaryValue* val);
     79 
     80 enum RunFunctionFlags {
     81   NONE = 0,
     82   INCLUDE_INCOGNITO = 1 << 0
     83 };
     84 
     85 // Run |function| with |args| and return the resulting error. Adds an error to
     86 // the current test if |function| returns a result. Takes ownership of
     87 // |function|.
     88 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
     89                                       const std::string& args,
     90                                       Browser* browser,
     91                                       RunFunctionFlags flags);
     92 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
     93                                       const std::string& args,
     94                                       Browser* browser);
     95 
     96 // Run |function| with |args| and return the result. Adds an error to the
     97 // current test if |function| returns an error. Takes ownership of
     98 // |function|. The caller takes ownership of the result.
     99 base::Value* RunFunctionAndReturnSingleResult(
    100     UIThreadExtensionFunction* function,
    101     const std::string& args,
    102     Browser* browser,
    103     RunFunctionFlags flags);
    104 base::Value* RunFunctionAndReturnSingleResult(
    105     UIThreadExtensionFunction* function,
    106     const std::string& args,
    107     Browser* browser);
    108 
    109 // Create and run |function| with |args|. Works with both synchronous and async
    110 // functions. Ownership of |function| remains with the caller.
    111 //
    112 // TODO(aa): It would be nice if |args| could be validated against the schema
    113 // that |function| expects. That way, we know that we are testing something
    114 // close to what the bindings would actually send.
    115 //
    116 // TODO(aa): I'm concerned that this style won't scale to all the bits and bobs
    117 // we're going to need to frob for all the different extension functions. But
    118 // we can refactor when we see what is needed.
    119 bool RunFunction(UIThreadExtensionFunction* function,
    120                  const std::string& args,
    121                  Browser* browser,
    122                  RunFunctionFlags flags);
    123 
    124 } // namespace extension_function_test_utils
    125 
    126 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_TEST_UTILS_H_
    127