chrome/browser/extensions/api/declarative_webrequest/webrequest_action_unittest.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 "extensions/browser/api/declarative_webrequest/webrequest_action.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/json/json_file_value_serializer.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/test/values_test_util.h"
  13 #include "base/time/time.h"
  14 #include "base/values.h"
  15 #include "chrome/common/chrome_paths.h"
  16 #include "chrome/common/extensions/extension_constants.h"
  17 #include "chrome/common/extensions/extension_test_util.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "extensions/browser/api/declarative_webrequest/request_stage.h"
  20 #include "extensions/browser/api/declarative_webrequest/webrequest_condition.h"
  21 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
  22 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
  23 #include "extensions/browser/info_map.h"
  24 #include "extensions/common/extension.h"
  25 #include "net/base/request_priority.h"
  26 #include "net/http/http_response_headers.h"
  27 #include "net/url_request/url_request.h"
  28 #include "net/url_request/url_request_test_util.h"
  29 #include "testing/gmock/include/gmock/gmock.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31
  32 using base::DictionaryValue;
  33 using base::ListValue;
  34 using extension_test_util::LoadManifestUnchecked;
  35 using testing::HasSubstr;
  36
  37 namespace extensions {
  38
  39 namespace {
  40
  41 const char kUnknownActionType[] = "unknownType";
  42
  43 scoped_ptr<WebRequestActionSet> CreateSetOfActions(const char* json) {
  44   scoped_ptr<base::Value> parsed_value(base::test::ParseJson(json));
  45   const base::ListValue* parsed_list;
  46   CHECK(parsed_value->GetAsList(&parsed_list));
  47
  48   WebRequestActionSet::AnyVector actions;
  49   for (base::ListValue::const_iterator it = parsed_list->begin();
  50        it != parsed_list->end();
  51        ++it) {
  52     const base::DictionaryValue* dict;
  53     CHECK((*it)->GetAsDictionary(&dict));
  54     actions.push_back(linked_ptr<base::Value>(dict->DeepCopy()));
  55   }
  56
  57   std::string error;
  58   bool bad_message = false;
  59
  60   scoped_ptr<WebRequestActionSet> action_set(
  61       WebRequestActionSet::Create(NULL, NULL, actions, &error, &bad_message));
  62   EXPECT_EQ("", error);
  63   EXPECT_FALSE(bad_message);
  64   CHECK(action_set);
  65   return action_set.Pass();
  66 }
  67
  68 }  // namespace
  69
  70 namespace keys = declarative_webrequest_constants;
  71
  72 class WebRequestActionWithThreadsTest : public testing::Test {
  73  public:
  74   WebRequestActionWithThreadsTest()
  75       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
  76
  77  protected:
  78   void SetUp() override;
  79
  80   // Creates a URL request for URL |url_string|, and applies the actions from
  81   // |action_set| as if they were triggered by the extension with
  82   // |extension_id| during |stage|.
  83   bool ActionWorksOnRequest(const char* url_string,
  84                             const std::string& extension_id,
  85                             const WebRequestActionSet* action_set,
  86                             RequestStage stage);
  87
  88   // Expects a JSON description of an |action| requiring <all_urls> host
  89   // permission, and checks that only an extensions with full host permissions
  90   // can execute that action at |stage|. Also checks that the action is not
  91   // executable for http://clients1.google.com.
  92   void CheckActionNeedsAllUrls(const char* action, RequestStage stage);
  93
  94   net::TestURLRequestContext context_;
  95
  96   // An extension with *.com host permissions and the DWR permission.
  97   scoped_refptr<Extension> extension_;
  98   // An extension with host permissions for all URLs and the DWR permission.
  99   scoped_refptr<Extension> extension_all_urls_;
 100   scoped_refptr<InfoMap> extension_info_map_;
 101
 102  private:
 103   content::TestBrowserThreadBundle thread_bundle_;
 104 };
 105
 106 void WebRequestActionWithThreadsTest::SetUp() {
 107   testing::Test::SetUp();
 108
 109   std::string error;
 110   extension_ = LoadManifestUnchecked("permissions",
 111                                      "web_request_com_host_permissions.json",
 112                                      Manifest::INVALID_LOCATION,
 113                                      Extension::NO_FLAGS,
 114                                      "ext_id_1",
 115                                      &error);
 116   ASSERT_TRUE(extension_.get()) << error;
 117   extension_all_urls_ =
 118       LoadManifestUnchecked("permissions",
 119                             "web_request_all_host_permissions.json",
 120                             Manifest::INVALID_LOCATION,
 121                             Extension::NO_FLAGS,
 122                             "ext_id_2",
 123                             &error);
 124   ASSERT_TRUE(extension_all_urls_.get()) << error;
 125   extension_info_map_ = new InfoMap;
 126   ASSERT_TRUE(extension_info_map_.get());
 127   extension_info_map_->AddExtension(
 128       extension_.get(),
 129       base::Time::Now(),
 130       false /*incognito_enabled*/,
 131       false /*notifications_disabled*/);
 132   extension_info_map_->AddExtension(extension_all_urls_.get(),
 133                                     base::Time::Now(),
 134                                     false /*incognito_enabled*/,
 135                                     false /*notifications_disabled*/);
 136 }
 137
 138 bool WebRequestActionWithThreadsTest::ActionWorksOnRequest(
 139     const char* url_string,
 140     const std::string& extension_id,
 141     const WebRequestActionSet* action_set,
 142     RequestStage stage) {
 143   scoped_ptr<net::URLRequest> regular_request(context_.CreateRequest(
 144       GURL(url_string), net::DEFAULT_PRIORITY, NULL));
 145   std::list<LinkedPtrEventResponseDelta> deltas;
 146   scoped_refptr<net::HttpResponseHeaders> headers(
 147       new net::HttpResponseHeaders(""));
 148   WebRequestData request_data(regular_request.get(), stage, headers.get());
 149   std::set<std::string> ignored_tags;
 150   WebRequestAction::ApplyInfo apply_info = { extension_info_map_.get(),
 151                                              request_data,
 152                                              false /*crosses_incognito*/,
 153                                              &deltas, &ignored_tags };
 154   action_set->Apply(extension_id, base::Time(), &apply_info);
 155   return (1u == deltas.size() || 0u < ignored_tags.size());
 156 }
 157
 158 void WebRequestActionWithThreadsTest::CheckActionNeedsAllUrls(
 159     const char* action,
 160     RequestStage stage) {
 161   scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(action));
 162
 163   // Although |extension_| has matching *.com host permission, |action|
 164   // is intentionally forbidden -- in Declarative WR, host permission
 165   // for less than all URLs are ignored (except in SendMessageToExtension).
 166   EXPECT_FALSE(ActionWorksOnRequest(
 167       "http://test.com", extension_->id(), action_set.get(), stage));
 168   // With the "<all_urls>" host permission they are allowed.
 169   EXPECT_TRUE(ActionWorksOnRequest(
 170       "http://test.com", extension_all_urls_->id(), action_set.get(), stage));
 171
 172   // The protected URLs should not be touched at all.
 173   EXPECT_FALSE(ActionWorksOnRequest(
 174       "http://clients1.google.com", extension_->id(), action_set.get(), stage));
 175   EXPECT_FALSE(ActionWorksOnRequest("http://clients1.google.com",
 176                                     extension_all_urls_->id(),
 177                                     action_set.get(),
 178                                     stage));
 179 }
 180
 181 TEST(WebRequestActionTest, CreateAction) {
 182   std::string error;
 183   bool bad_message = false;
 184   scoped_refptr<const WebRequestAction> result;
 185
 186   // Test wrong data type passed.
 187   error.clear();
 188   base::ListValue empty_list;
 189   result = WebRequestAction::Create(
 190       NULL, NULL, empty_list, &error, &bad_message);
 191   EXPECT_TRUE(bad_message);
 192   EXPECT_FALSE(result.get());
 193
 194   // Test missing instanceType element.
 195   base::DictionaryValue input;
 196   error.clear();
 197   result = WebRequestAction::Create(NULL, NULL, input, &error, &bad_message);
 198   EXPECT_TRUE(bad_message);
 199   EXPECT_FALSE(result.get());
 200
 201   // Test wrong instanceType element.
 202   input.SetString(keys::kInstanceTypeKey, kUnknownActionType);
 203   error.clear();
 204   result = WebRequestAction::Create(NULL, NULL, input, &error, &bad_message);
 205   EXPECT_NE("", error);
 206   EXPECT_FALSE(result.get());
 207
 208   // Test success
 209   input.SetString(keys::kInstanceTypeKey, keys::kCancelRequestType);
 210   error.clear();
 211   result = WebRequestAction::Create(NULL, NULL, input, &error, &bad_message);
 212   EXPECT_EQ("", error);
 213   EXPECT_FALSE(bad_message);
 214   ASSERT_TRUE(result.get());
 215   EXPECT_EQ(WebRequestAction::ACTION_CANCEL_REQUEST, result->type());
 216 }
 217
 218 TEST(WebRequestActionTest, CreateActionSet) {
 219   std::string error;
 220   bool bad_message = false;
 221   scoped_ptr<WebRequestActionSet> result;
 222
 223   WebRequestActionSet::AnyVector input;
 224
 225   // Test empty input.
 226   error.clear();
 227   result = WebRequestActionSet::Create(NULL, NULL, input, &error, &bad_message);
 228   EXPECT_TRUE(error.empty()) << error;
 229   EXPECT_FALSE(bad_message);
 230   ASSERT_TRUE(result.get());
 231   EXPECT_TRUE(result->actions().empty());
 232   EXPECT_EQ(std::numeric_limits<int>::min(), result->GetMinimumPriority());
 233
 234   base::DictionaryValue correct_action;
 235   correct_action.SetString(keys::kInstanceTypeKey, keys::kIgnoreRulesType);
 236   correct_action.SetInteger(keys::kLowerPriorityThanKey, 10);
 237   base::DictionaryValue incorrect_action;
 238   incorrect_action.SetString(keys::kInstanceTypeKey, kUnknownActionType);
 239
 240   // Test success.
 241   input.push_back(linked_ptr<base::Value>(correct_action.DeepCopy()));
 242   error.clear();
 243   result = WebRequestActionSet::Create(NULL, NULL, input, &error, &bad_message);
 244   EXPECT_TRUE(error.empty()) << error;
 245   EXPECT_FALSE(bad_message);
 246   ASSERT_TRUE(result.get());
 247   ASSERT_EQ(1u, result->actions().size());
 248   EXPECT_EQ(WebRequestAction::ACTION_IGNORE_RULES,
 249             result->actions()[0]->type());
 250   EXPECT_EQ(10, result->GetMinimumPriority());
 251
 252   // Test failure.
 253   input.push_back(linked_ptr<base::Value>(incorrect_action.DeepCopy()));
 254   error.clear();
 255   result = WebRequestActionSet::Create(NULL, NULL, input, &error, &bad_message);
 256   EXPECT_NE("", error);
 257   EXPECT_FALSE(result.get());
 258 }
 259
 260 // Test capture group syntax conversions of WebRequestRedirectByRegExAction
 261 TEST(WebRequestActionTest, PerlToRe2Style) {
 262 #define CallPerlToRe2Style WebRequestRedirectByRegExAction::PerlToRe2Style
 263   // foo$1bar -> foo\1bar
 264   EXPECT_EQ("foo\\1bar", CallPerlToRe2Style("foo$1bar"));
 265   // foo\$1bar -> foo$1bar
 266   EXPECT_EQ("foo$1bar", CallPerlToRe2Style("foo\\$1bar"));
 267   // foo\\$1bar -> foo\\\1bar
 268   EXPECT_EQ("foo\\\\\\1bar", CallPerlToRe2Style("foo\\\\$1bar"));
 269   // foo\bar -> foobar
 270   EXPECT_EQ("foobar", CallPerlToRe2Style("foo\\bar"));
 271   // foo$bar -> foo$bar
 272   EXPECT_EQ("foo$bar", CallPerlToRe2Style("foo$bar"));
 273 #undef CallPerlToRe2Style
 274 }
 275
 276 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRedirect) {
 277   const char kAction[] =
 278       "[{"
 279       " \"instanceType\": \"declarativeWebRequest.RedirectRequest\","
 280       " \"redirectUrl\": \"http://www.foobar.com\""
 281       "}]";
 282   CheckActionNeedsAllUrls(kAction, ON_BEFORE_REQUEST);
 283   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 284 }
 285
 286 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRedirectByRegEx) {
 287   const char kAction[] =
 288       "[{"
 289       " \"instanceType\": \"declarativeWebRequest.RedirectByRegEx\","
 290       " \"from\": \".*\","
 291       " \"to\": \"http://www.foobar.com\""
 292       "}]";
 293   CheckActionNeedsAllUrls(kAction, ON_BEFORE_REQUEST);
 294 }
 295
 296 TEST_F(WebRequestActionWithThreadsTest, PermissionsToSetRequestHeader) {
 297   const char kAction[] =
 298       "[{"
 299       " \"instanceType\": \"declarativeWebRequest.SetRequestHeader\","
 300       " \"name\": \"testname\","
 301       " \"value\": \"testvalue\""
 302       "}]";
 303   CheckActionNeedsAllUrls(kAction, ON_BEFORE_SEND_HEADERS);
 304 }
 305
 306 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRemoveRequestHeader) {
 307   const char kAction[] =
 308       "[{"
 309       " \"instanceType\": \"declarativeWebRequest.RemoveRequestHeader\","
 310       " \"name\": \"testname\""
 311       "}]";
 312   CheckActionNeedsAllUrls(kAction, ON_BEFORE_SEND_HEADERS);
 313 }
 314
 315 TEST_F(WebRequestActionWithThreadsTest, PermissionsToAddResponseHeader) {
 316   const char kAction[] =
 317       "[{"
 318       " \"instanceType\": \"declarativeWebRequest.AddResponseHeader\","
 319       " \"name\": \"testname\","
 320       " \"value\": \"testvalue\""
 321       "}]";
 322   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 323 }
 324
 325 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRemoveResponseHeader) {
 326   const char kAction[] =
 327       "[{"
 328       " \"instanceType\": \"declarativeWebRequest.RemoveResponseHeader\","
 329       " \"name\": \"testname\""
 330       "}]";
 331   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 332 }
 333
 334 TEST_F(WebRequestActionWithThreadsTest, PermissionsToSendMessageToExtension) {
 335   const char kAction[] =
 336       "[{"
 337       " \"instanceType\": \"declarativeWebRequest.SendMessageToExtension\","
 338       " \"message\": \"testtext\""
 339       "}]";
 340   scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 341
 342   // For sending messages, specific host permissions actually matter.
 343   EXPECT_TRUE(ActionWorksOnRequest("http://test.com",
 344                                    extension_->id(),
 345                                    action_set.get(),
 346                                    ON_BEFORE_REQUEST));
 347   // With the "<all_urls>" host permission they are allowed.
 348   EXPECT_TRUE(ActionWorksOnRequest("http://test.com",
 349                                    extension_all_urls_->id(),
 350                                    action_set.get(),
 351                                    ON_BEFORE_REQUEST));
 352
 353   // The protected URLs should not be touched at all.
 354   EXPECT_FALSE(ActionWorksOnRequest("http://clients1.google.com",
 355                                     extension_->id(),
 356                                     action_set.get(),
 357                                     ON_BEFORE_REQUEST));
 358   EXPECT_FALSE(ActionWorksOnRequest("http://clients1.google.com",
 359                                     extension_all_urls_->id(),
 360                                     action_set.get(),
 361                                     ON_BEFORE_REQUEST));
 362 }
 363
 364 TEST_F(WebRequestActionWithThreadsTest, PermissionsToAddRequestCookie) {
 365   const char kAction[] =
 366       "[{"
 367       " \"instanceType\": \"declarativeWebRequest.AddRequestCookie\","
 368       " \"cookie\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 369       "}]";
 370   CheckActionNeedsAllUrls(kAction, ON_BEFORE_SEND_HEADERS);
 371 }
 372
 373 TEST_F(WebRequestActionWithThreadsTest, PermissionsToAddResponseCookie) {
 374   const char kAction[] =
 375       "[{"
 376       " \"instanceType\": \"declarativeWebRequest.AddResponseCookie\","
 377       " \"cookie\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 378       "}]";
 379   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 380 }
 381
 382 TEST_F(WebRequestActionWithThreadsTest, PermissionsToEditRequestCookie) {
 383   const char kAction[] =
 384       "[{"
 385       " \"instanceType\": \"declarativeWebRequest.EditRequestCookie\","
 386       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" },"
 387       " \"modification\": { \"name\": \"name2\", \"value\": \"value2\" }"
 388       "}]";
 389   CheckActionNeedsAllUrls(kAction, ON_BEFORE_SEND_HEADERS);
 390 }
 391
 392 TEST_F(WebRequestActionWithThreadsTest, PermissionsToEditResponseCookie) {
 393   const char kAction[] =
 394       "[{"
 395       " \"instanceType\": \"declarativeWebRequest.EditResponseCookie\","
 396       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" },"
 397       " \"modification\": { \"name\": \"name2\", \"value\": \"value2\" }"
 398       "}]";
 399   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 400 }
 401
 402 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRemoveRequestCookie) {
 403   const char kAction[] =
 404       "[{"
 405       " \"instanceType\": \"declarativeWebRequest.RemoveRequestCookie\","
 406       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 407       "}]";
 408   CheckActionNeedsAllUrls(kAction, ON_BEFORE_SEND_HEADERS);
 409 }
 410
 411 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRemoveResponseCookie) {
 412   const char kAction[] =
 413       "[{"
 414       " \"instanceType\": \"declarativeWebRequest.RemoveResponseCookie\","
 415       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 416       "}]";
 417   CheckActionNeedsAllUrls(kAction, ON_HEADERS_RECEIVED);
 418 }
 419
 420 TEST_F(WebRequestActionWithThreadsTest, PermissionsToCancel) {
 421   const char kAction[] =
 422       "[{"
 423       " \"instanceType\": \"declarativeWebRequest.CancelRequest\""
 424       "}]";
 425   scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 426
 427   // Cancelling requests works without full host permissions.
 428   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
 429                                    extension_->id(),
 430                                    action_set.get(),
 431                                    ON_BEFORE_REQUEST));
 432 }
 433
 434 TEST_F(WebRequestActionWithThreadsTest,
 435        PermissionsToRedirectToTransparentImage) {
 436   const char kAction[] =
 437       "[{"
 438       " \"instanceType\": \"declarativeWebRequest.RedirectToTransparentImage\""
 439       "}]";
 440   scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 441
 442   // Redirecting to transparent images works without full host permissions.
 443   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
 444                                    extension_->id(),
 445                                    action_set.get(),
 446                                    ON_BEFORE_REQUEST));
 447   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
 448                                    extension_->id(),
 449                                    action_set.get(),
 450                                    ON_HEADERS_RECEIVED));
 451 }
 452
 453 TEST_F(WebRequestActionWithThreadsTest, PermissionsToRedirectToEmptyDocument) {
 454   const char kAction[] =
 455       "[{"
 456       " \"instanceType\": \"declarativeWebRequest.RedirectToEmptyDocument\""
 457       "}]";
 458   scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 459
 460   // Redirecting to the empty document works without full host permissions.
 461   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
 462                                    extension_->id(),
 463                                    action_set.get(),
 464                                    ON_BEFORE_REQUEST));
 465   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
 466                                    extension_->id(),
 467                                    action_set.get(),
 468                                    ON_HEADERS_RECEIVED));
 469 }
 470
 471 TEST_F(WebRequestActionWithThreadsTest, PermissionsToIgnore) {
 472   const char kAction[] =
 473       "[{"
 474       " \"instanceType\": \"declarativeWebRequest.IgnoreRules\","
 475       " \"lowerPriorityThan\": 123,"
 476       " \"hasTag\": \"some_tag\""
 477       "}]";
 478   scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kAction));
 479
 480   // Ignoring rules works without full host permissions.
 481   EXPECT_TRUE(ActionWorksOnRequest("http://test.org",
 482                                    extension_->id(),
 483                                    action_set.get(),
 484                                    ON_BEFORE_REQUEST));
 485 }
 486
 487 TEST(WebRequestActionTest, GetName) {
 488   const char kActions[] =
 489       "[{"
 490       " \"instanceType\": \"declarativeWebRequest.RedirectRequest\","
 491       " \"redirectUrl\": \"http://www.foobar.com\""
 492       "},"
 493       "{"
 494       " \"instanceType\": \"declarativeWebRequest.RedirectByRegEx\","
 495       " \"from\": \".*\","
 496       " \"to\": \"http://www.foobar.com\""
 497       "},"
 498       "{"
 499       " \"instanceType\": \"declarativeWebRequest.SetRequestHeader\","
 500       " \"name\": \"testname\","
 501       " \"value\": \"testvalue\""
 502       "},"
 503       "{"
 504       " \"instanceType\": \"declarativeWebRequest.RemoveRequestHeader\","
 505       " \"name\": \"testname\""
 506       "},"
 507       "{"
 508       " \"instanceType\": \"declarativeWebRequest.AddResponseHeader\","
 509       " \"name\": \"testname\","
 510       " \"value\": \"testvalue\""
 511       "},"
 512       "{"
 513       " \"instanceType\": \"declarativeWebRequest.RemoveResponseHeader\","
 514       " \"name\": \"testname\""
 515       "},"
 516       "{"
 517       " \"instanceType\": \"declarativeWebRequest.SendMessageToExtension\","
 518       " \"message\": \"testtext\""
 519       "},"
 520       "{"
 521       " \"instanceType\": \"declarativeWebRequest.AddRequestCookie\","
 522       " \"cookie\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 523       "},"
 524       "{"
 525       " \"instanceType\": \"declarativeWebRequest.AddResponseCookie\","
 526       " \"cookie\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 527       "},"
 528       "{"
 529       " \"instanceType\": \"declarativeWebRequest.EditRequestCookie\","
 530       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" },"
 531       " \"modification\": { \"name\": \"name2\", \"value\": \"value2\" }"
 532       "},"
 533       "{"
 534       " \"instanceType\": \"declarativeWebRequest.EditResponseCookie\","
 535       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" },"
 536       " \"modification\": { \"name\": \"name2\", \"value\": \"value2\" }"
 537       "},"
 538       "{"
 539       " \"instanceType\": \"declarativeWebRequest.RemoveRequestCookie\","
 540       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 541       "},"
 542       "{"
 543       " \"instanceType\": \"declarativeWebRequest.RemoveResponseCookie\","
 544       " \"filter\": { \"name\": \"cookiename\", \"value\": \"cookievalue\" }"
 545       "},"
 546       "{"
 547       " \"instanceType\": \"declarativeWebRequest.CancelRequest\""
 548       "},"
 549       "{"
 550       " \"instanceType\": \"declarativeWebRequest.RedirectToTransparentImage\""
 551       "},"
 552       "{"
 553       " \"instanceType\": \"declarativeWebRequest.RedirectToEmptyDocument\""
 554       "},"
 555       "{"
 556       " \"instanceType\": \"declarativeWebRequest.IgnoreRules\","
 557       " \"lowerPriorityThan\": 123,"
 558       " \"hasTag\": \"some_tag\""
 559       "}]";
 560   const char* const kExpectedNames[] = {
 561     "declarativeWebRequest.RedirectRequest",
 562     "declarativeWebRequest.RedirectByRegEx",
 563     "declarativeWebRequest.SetRequestHeader",
 564     "declarativeWebRequest.RemoveRequestHeader",
 565     "declarativeWebRequest.AddResponseHeader",
 566     "declarativeWebRequest.RemoveResponseHeader",
 567     "declarativeWebRequest.SendMessageToExtension",
 568     "declarativeWebRequest.AddRequestCookie",
 569     "declarativeWebRequest.AddResponseCookie",
 570     "declarativeWebRequest.EditRequestCookie",
 571     "declarativeWebRequest.EditResponseCookie",
 572     "declarativeWebRequest.RemoveRequestCookie",
 573     "declarativeWebRequest.RemoveResponseCookie",
 574     "declarativeWebRequest.CancelRequest",
 575     "declarativeWebRequest.RedirectToTransparentImage",
 576     "declarativeWebRequest.RedirectToEmptyDocument",
 577     "declarativeWebRequest.IgnoreRules",
 578   };
 579   scoped_ptr<WebRequestActionSet> action_set(CreateSetOfActions(kActions));
 580   ASSERT_EQ(arraysize(kExpectedNames), action_set->actions().size());
 581   size_t index = 0;
 582   for (WebRequestActionSet::Actions::const_iterator it =
 583            action_set->actions().begin();
 584        it != action_set->actions().end();
 585        ++it) {
 586     EXPECT_EQ(kExpectedNames[index], (*it)->GetName());
 587     ++index;
 588   }
 589 }
 590
 591 }  // namespace extensions