chrome/browser/extensions/extension_function_test_utils.cc

   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 #include "chrome/browser/extensions/extension_function_test_utils.h"
   6
   7 #include <string>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/json/json_reader.h"
  11 #include "base/values.h"
  12 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
  13 #include "chrome/browser/extensions/extension_function_dispatcher.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/ui/browser.h"
  16 #include "chrome/test/base/ui_test_utils.h"
  17 #include "extensions/browser/extension_function.h"
  18 #include "extensions/common/extension.h"
  19 #include "extensions/common/id_util.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 using content::WebContents;
  23 using extensions::Extension;
  24 using extensions::Manifest;
  25 namespace keys = extensions::tabs_constants;
  26
  27 namespace {
  28
  29 class TestFunctionDispatcherDelegate
  30     : public ExtensionFunctionDispatcher::Delegate {
  31  public:
  32   explicit TestFunctionDispatcherDelegate(Browser* browser) :
  33       browser_(browser) {}
  34   virtual ~TestFunctionDispatcherDelegate() {}
  35
  36  private:
  37   virtual extensions::WindowController* GetExtensionWindowController()
  38       const OVERRIDE {
  39     return browser_->extension_window_controller();
  40   }
  41
  42   virtual WebContents* GetAssociatedWebContents() const OVERRIDE {
  43     return NULL;
  44   }
  45
  46   Browser* browser_;
  47 };
  48
  49 }  // namespace
  50
  51 namespace extension_function_test_utils {
  52
  53 base::Value* ParseJSON(const std::string& data) {
  54   return base::JSONReader::Read(data);
  55 }
  56
  57 base::ListValue* ParseList(const std::string& data) {
  58   scoped_ptr<base::Value> result(ParseJSON(data));
  59   if (result.get() && result->IsType(base::Value::TYPE_LIST))
  60     return static_cast<base::ListValue*>(result.release());
  61   else
  62     return NULL;
  63 }
  64
  65 base::DictionaryValue* ParseDictionary(
  66     const std::string& data) {
  67   scoped_ptr<base::Value> result(ParseJSON(data));
  68   if (result.get() && result->IsType(base::Value::TYPE_DICTIONARY))
  69     return static_cast<base::DictionaryValue*>(result.release());
  70   else
  71     return NULL;
  72 }
  73
  74 bool GetBoolean(base::DictionaryValue* val, const std::string& key) {
  75   bool result = false;
  76   if (!val->GetBoolean(key, &result))
  77       ADD_FAILURE() << key << " does not exist or is not a boolean.";
  78   return result;
  79 }
  80
  81 int GetInteger(base::DictionaryValue* val, const std::string& key) {
  82   int result = 0;
  83   if (!val->GetInteger(key, &result))
  84     ADD_FAILURE() << key << " does not exist or is not an integer.";
  85   return result;
  86 }
  87
  88 std::string GetString(base::DictionaryValue* val, const std::string& key) {
  89   std::string result;
  90   if (!val->GetString(key, &result))
  91     ADD_FAILURE() << key << " does not exist or is not a string.";
  92   return result;
  93 }
  94
  95 base::DictionaryValue* ToDictionary(base::Value* val) {
  96   EXPECT_TRUE(val);
  97   EXPECT_EQ(base::Value::TYPE_DICTIONARY, val->GetType());
  98   return static_cast<base::DictionaryValue*>(val);
  99 }
 100
 101 base::ListValue* ToList(base::Value* val) {
 102   EXPECT_TRUE(val);
 103   EXPECT_EQ(base::Value::TYPE_LIST, val->GetType());
 104   return static_cast<base::ListValue*>(val);
 105 }
 106
 107 scoped_refptr<Extension> CreateEmptyExtension() {
 108   return CreateEmptyExtensionWithLocation(Manifest::INTERNAL);
 109 }
 110
 111 scoped_refptr<Extension> CreateEmptyExtensionWithLocation(
 112     Manifest::Location location) {
 113   scoped_ptr<base::DictionaryValue> test_extension_value(
 114       ParseDictionary("{\"name\": \"Test\", \"version\": \"1.0\"}"));
 115   return CreateExtension(location, test_extension_value.get(), std::string());
 116 }
 117
 118 scoped_refptr<Extension> CreateEmptyExtension(
 119     const std::string& id_input) {
 120   scoped_ptr<base::DictionaryValue> test_extension_value(
 121       ParseDictionary("{\"name\": \"Test\", \"version\": \"1.0\"}"));
 122   return CreateExtension(Manifest::INTERNAL, test_extension_value.get(),
 123                          id_input);
 124 }
 125
 126 scoped_refptr<Extension> CreateExtension(
 127     base::DictionaryValue* test_extension_value) {
 128   return CreateExtension(Manifest::INTERNAL, test_extension_value,
 129                          std::string());
 130 }
 131
 132 scoped_refptr<Extension> CreateExtension(
 133     Manifest::Location location,
 134     base::DictionaryValue* test_extension_value,
 135     const std::string& id_input) {
 136   std::string error;
 137   const base::FilePath test_extension_path;
 138   std::string id;
 139   if (!id_input.empty())
 140     id = extensions::id_util::GenerateId(id_input);
 141   scoped_refptr<Extension> extension(Extension::Create(
 142       test_extension_path,
 143       location,
 144       *test_extension_value,
 145       Extension::NO_FLAGS,
 146       id,
 147       &error));
 148   EXPECT_TRUE(error.empty()) << "Could not parse test extension " << error;
 149   return extension;
 150 }
 151
 152 bool HasPrivacySensitiveFields(base::DictionaryValue* val) {
 153   std::string result;
 154   if (val->GetString(keys::kUrlKey, &result) ||
 155       val->GetString(keys::kTitleKey, &result) ||
 156       val->GetString(keys::kFaviconUrlKey, &result))
 157     return true;
 158   return false;
 159 }
 160
 161 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
 162                                       const std::string& args,
 163                                       Browser* browser) {
 164   return RunFunctionAndReturnError(function, args, browser, NONE);
 165 }
 166 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
 167                                       const std::string& args,
 168                                       Browser* browser,
 169                                       RunFunctionFlags flags) {
 170   scoped_refptr<ExtensionFunction> function_owner(function);
 171   // Without a callback the function will not generate a result.
 172   function->set_has_callback(true);
 173   RunFunction(function, args, browser, flags);
 174   EXPECT_FALSE(function->GetResultList()) << "Did not expect a result";
 175   return function->GetError();
 176 }
 177
 178 base::Value* RunFunctionAndReturnSingleResult(
 179     UIThreadExtensionFunction* function,
 180     const std::string& args,
 181     Browser* browser) {
 182   return RunFunctionAndReturnSingleResult(function, args, browser, NONE);
 183 }
 184 base::Value* RunFunctionAndReturnSingleResult(
 185     UIThreadExtensionFunction* function,
 186     const std::string& args,
 187     Browser* browser,
 188     RunFunctionFlags flags) {
 189   scoped_refptr<ExtensionFunction> function_owner(function);
 190   // Without a callback the function will not generate a result.
 191   function->set_has_callback(true);
 192   RunFunction(function, args, browser, flags);
 193   EXPECT_TRUE(function->GetError().empty()) << "Unexpected error: "
 194       << function->GetError();
 195   const base::Value* single_result = NULL;
 196   if (function->GetResultList() != NULL &&
 197       function->GetResultList()->Get(0, &single_result)) {
 198     return single_result->DeepCopy();
 199   }
 200   return NULL;
 201 }
 202
 203 // This helps us be able to wait until an UIThreadExtensionFunction calls
 204 // SendResponse.
 205 class SendResponseDelegate
 206     : public UIThreadExtensionFunction::DelegateForTests {
 207  public:
 208   SendResponseDelegate() : should_post_quit_(false) {}
 209
 210   virtual ~SendResponseDelegate() {}
 211
 212   void set_should_post_quit(bool should_quit) {
 213     should_post_quit_ = should_quit;
 214   }
 215
 216   bool HasResponse() {
 217     return response_.get() != NULL;
 218   }
 219
 220   bool GetResponse() {
 221     EXPECT_TRUE(HasResponse());
 222     return *response_.get();
 223   }
 224
 225   virtual void OnSendResponse(UIThreadExtensionFunction* function,
 226                               bool success,
 227                               bool bad_message) OVERRIDE {
 228     ASSERT_FALSE(bad_message);
 229     ASSERT_FALSE(HasResponse());
 230     response_.reset(new bool);
 231     *response_ = success;
 232     if (should_post_quit_) {
 233       base::MessageLoopForUI::current()->Quit();
 234     }
 235   }
 236
 237  private:
 238   scoped_ptr<bool> response_;
 239   bool should_post_quit_;
 240 };
 241
 242 bool RunFunction(UIThreadExtensionFunction* function,
 243                  const std::string& args,
 244                  Browser* browser,
 245                  RunFunctionFlags flags) {
 246   SendResponseDelegate response_delegate;
 247   function->set_test_delegate(&response_delegate);
 248   scoped_ptr<base::ListValue> parsed_args(ParseList(args));
 249   EXPECT_TRUE(parsed_args.get()) <<
 250       "Could not parse extension function arguments: " << args;
 251   function->SetArgs(parsed_args.get());
 252
 253   TestFunctionDispatcherDelegate dispatcher_delegate(browser);
 254   ExtensionFunctionDispatcher dispatcher(
 255       browser->profile(), &dispatcher_delegate);
 256   function->set_dispatcher(dispatcher.AsWeakPtr());
 257
 258   function->set_context(browser->profile());
 259   function->set_include_incognito(flags & INCLUDE_INCOGNITO);
 260   function->Run();
 261
 262   // If the RunImpl of |function| didn't already call SendResponse, run the
 263   // message loop until they do.
 264   if (!response_delegate.HasResponse()) {
 265     response_delegate.set_should_post_quit(true);
 266     content::RunMessageLoop();
 267   }
 268
 269   EXPECT_TRUE(response_delegate.HasResponse());
 270   return response_delegate.GetResponse();
 271 }
 272
 273 } // namespace extension_function_test_utils