OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_action
.h" | 5 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_action
.h" |
6 | 6 |
7 #include <limits> | 7 #include <limits> |
8 | 8 |
9 #include "base/lazy_instance.h" | 9 #include "base/lazy_instance.h" |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
(...skipping 23 matching lines...) Expand all Loading... |
34 "EUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg=="; | 34 "EUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg=="; |
35 const char kEmptyDocumentUrl[] = "data:text/html,"; | 35 const char kEmptyDocumentUrl[] = "data:text/html,"; |
36 | 36 |
37 #define INPUT_FORMAT_VALIDATE(test) do { \ | 37 #define INPUT_FORMAT_VALIDATE(test) do { \ |
38 if (!(test)) { \ | 38 if (!(test)) { \ |
39 *bad_message = true; \ | 39 *bad_message = true; \ |
40 return scoped_ptr<WebRequestAction>(NULL); \ | 40 return scoped_ptr<WebRequestAction>(NULL); \ |
41 } \ | 41 } \ |
42 } while (0) | 42 } while (0) |
43 | 43 |
| 44 scoped_ptr<helpers::RequestCookie> ParseRequestCookie( |
| 45 const DictionaryValue* dict) { |
| 46 scoped_ptr<helpers::RequestCookie> result(new helpers::RequestCookie); |
| 47 std::string tmp; |
| 48 if (dict->GetString(keys::kNameKey, &tmp)) |
| 49 result->name.reset(new std::string(tmp)); |
| 50 if (dict->GetString(keys::kValueKey, &tmp)) |
| 51 result->value.reset(new std::string(tmp)); |
| 52 return result.Pass(); |
| 53 } |
| 54 |
| 55 scoped_ptr<helpers::ResponseCookie> ParseResponseCookie( |
| 56 const DictionaryValue* dict) { |
| 57 scoped_ptr<helpers::ResponseCookie> result(new helpers::ResponseCookie); |
| 58 std::string string_tmp; |
| 59 int int_tmp = 0; |
| 60 bool bool_tmp = false; |
| 61 if (dict->GetString(keys::kNameKey, &string_tmp)) |
| 62 result->name.reset(new std::string(string_tmp)); |
| 63 if (dict->GetString(keys::kValueKey, &string_tmp)) |
| 64 result->value.reset(new std::string(string_tmp)); |
| 65 if (dict->GetString(keys::kExpiresKey, &string_tmp)) |
| 66 result->expires.reset(new std::string(string_tmp)); |
| 67 if (dict->GetInteger(keys::kMaxAgeKey, &int_tmp)) |
| 68 result->max_age.reset(new int(int_tmp)); |
| 69 if (dict->GetString(keys::kDomainKey, &string_tmp)) |
| 70 result->domain.reset(new std::string(string_tmp)); |
| 71 if (dict->GetString(keys::kPathKey, &string_tmp)) |
| 72 result->path.reset(new std::string(string_tmp)); |
| 73 if (dict->GetBoolean(keys::kSecureKey, &bool_tmp)) |
| 74 result->secure.reset(new bool(bool_tmp)); |
| 75 if (dict->GetBoolean(keys::kHttpOnlyKey, &bool_tmp)) |
| 76 result->http_only.reset(new bool(bool_tmp)); |
| 77 return result.Pass(); |
| 78 } |
| 79 |
44 // Helper function for WebRequestActions that can be instantiated by just | 80 // Helper function for WebRequestActions that can be instantiated by just |
45 // calling the constructor. | 81 // calling the constructor. |
46 template <class T> | 82 template <class T> |
47 scoped_ptr<WebRequestAction> CallConstructorFactoryMethod( | 83 scoped_ptr<WebRequestAction> CallConstructorFactoryMethod( |
48 const base::DictionaryValue* dict, | 84 const base::DictionaryValue* dict, |
49 std::string* error, | 85 std::string* error, |
50 bool* bad_message) { | 86 bool* bad_message) { |
51 return scoped_ptr<WebRequestAction>(new T); | 87 return scoped_ptr<WebRequestAction>(new T); |
52 } | 88 } |
53 | 89 |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
138 const base::DictionaryValue* dict, | 174 const base::DictionaryValue* dict, |
139 std::string* error, | 175 std::string* error, |
140 bool* bad_message) { | 176 bool* bad_message) { |
141 int minium_priority; | 177 int minium_priority; |
142 INPUT_FORMAT_VALIDATE( | 178 INPUT_FORMAT_VALIDATE( |
143 dict->GetInteger(keys::kLowerPriorityThanKey, &minium_priority)); | 179 dict->GetInteger(keys::kLowerPriorityThanKey, &minium_priority)); |
144 return scoped_ptr<WebRequestAction>( | 180 return scoped_ptr<WebRequestAction>( |
145 new WebRequestIgnoreRulesAction(minium_priority)); | 181 new WebRequestIgnoreRulesAction(minium_priority)); |
146 } | 182 } |
147 | 183 |
| 184 scoped_ptr<WebRequestAction> CreateRequestCookieAction( |
| 185 const base::DictionaryValue* dict, |
| 186 std::string* error, |
| 187 bool* bad_message) { |
| 188 using extension_web_request_api_helpers::RequestCookieModification; |
| 189 |
| 190 linked_ptr<RequestCookieModification> modification( |
| 191 new RequestCookieModification); |
| 192 |
| 193 // Get modification type. |
| 194 std::string instance_type; |
| 195 INPUT_FORMAT_VALIDATE( |
| 196 dict->GetString(keys::kInstanceTypeKey, &instance_type)); |
| 197 if (instance_type == keys::kAddRequestCookieType) |
| 198 modification->type = helpers::ADD; |
| 199 else if (instance_type == keys::kEditRequestCookieType) |
| 200 modification->type = helpers::EDIT; |
| 201 else if (instance_type == keys::kRemoveRequestCookieType) |
| 202 modification->type = helpers::REMOVE; |
| 203 else |
| 204 INPUT_FORMAT_VALIDATE(false); |
| 205 |
| 206 // Get filter. |
| 207 if (modification->type == helpers::EDIT || |
| 208 modification->type == helpers::REMOVE) { |
| 209 const DictionaryValue* filter = NULL; |
| 210 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter)); |
| 211 modification->filter = ParseRequestCookie(filter); |
| 212 } |
| 213 |
| 214 // Get new value. |
| 215 if (modification->type == helpers::ADD) { |
| 216 const DictionaryValue* value = NULL; |
| 217 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value)); |
| 218 modification->modification = ParseRequestCookie(value); |
| 219 } else if (modification->type == helpers::EDIT) { |
| 220 const DictionaryValue* value = NULL; |
| 221 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value)); |
| 222 modification->modification = ParseRequestCookie(value); |
| 223 } |
| 224 |
| 225 return scoped_ptr<WebRequestAction>( |
| 226 new WebRequestRequestCookieAction(modification)); |
| 227 } |
| 228 |
| 229 scoped_ptr<WebRequestAction> CreateResponseCookieAction( |
| 230 const base::DictionaryValue* dict, |
| 231 std::string* error, |
| 232 bool* bad_message) { |
| 233 using extension_web_request_api_helpers::ResponseCookieModification; |
| 234 |
| 235 linked_ptr<ResponseCookieModification> modification( |
| 236 new ResponseCookieModification); |
| 237 |
| 238 // Get modification type. |
| 239 std::string instance_type; |
| 240 INPUT_FORMAT_VALIDATE( |
| 241 dict->GetString(keys::kInstanceTypeKey, &instance_type)); |
| 242 if (instance_type == keys::kAddResponseCookieType) |
| 243 modification->type = helpers::ADD; |
| 244 else if (instance_type == keys::kEditResponseCookieType) |
| 245 modification->type = helpers::EDIT; |
| 246 else if (instance_type == keys::kRemoveResponseCookieType) |
| 247 modification->type = helpers::REMOVE; |
| 248 else |
| 249 INPUT_FORMAT_VALIDATE(false); |
| 250 |
| 251 // Get filter. |
| 252 if (modification->type == helpers::EDIT || |
| 253 modification->type == helpers::REMOVE) { |
| 254 const DictionaryValue* filter = NULL; |
| 255 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter)); |
| 256 modification->filter = ParseResponseCookie(filter); |
| 257 } |
| 258 |
| 259 // Get new value. |
| 260 if (modification->type == helpers::ADD) { |
| 261 const DictionaryValue* value = NULL; |
| 262 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value)); |
| 263 modification->modification = ParseResponseCookie(value); |
| 264 } else if (modification->type == helpers::EDIT) { |
| 265 const DictionaryValue* value = NULL; |
| 266 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value)); |
| 267 modification->modification = ParseResponseCookie(value); |
| 268 } |
| 269 |
| 270 return scoped_ptr<WebRequestAction>( |
| 271 new WebRequestResponseCookieAction(modification)); |
| 272 } |
| 273 |
148 struct WebRequestActionFactory { | 274 struct WebRequestActionFactory { |
149 // Factory methods for WebRequestAction instances. |dict| contains the json | 275 // Factory methods for WebRequestAction instances. |dict| contains the json |
150 // dictionary that describes the action. |error| is used to return error | 276 // dictionary that describes the action. |error| is used to return error |
151 // messages in case the extension passed an action that was syntactically | 277 // messages in case the extension passed an action that was syntactically |
152 // correct but semantically incorrect. |bad_message| is set to true in case | 278 // correct but semantically incorrect. |bad_message| is set to true in case |
153 // |dict| does not confirm to the validated JSON specification. | 279 // |dict| does not confirm to the validated JSON specification. |
154 typedef scoped_ptr<WebRequestAction> | 280 typedef scoped_ptr<WebRequestAction> |
155 (* FactoryMethod)(const base::DictionaryValue* /* dict */ , | 281 (* FactoryMethod)(const base::DictionaryValue* /* dict */ , |
156 std::string* /* error */, | 282 std::string* /* error */, |
157 bool* /* bad_message */); | 283 bool* /* bad_message */); |
158 std::map<std::string, FactoryMethod> factory_methods; | 284 std::map<std::string, FactoryMethod> factory_methods; |
159 | 285 |
160 WebRequestActionFactory() { | 286 WebRequestActionFactory() { |
| 287 factory_methods[keys::kAddRequestCookieType] = |
| 288 &CreateRequestCookieAction; |
| 289 factory_methods[keys::kAddResponseCookieType] = |
| 290 &CreateResponseCookieAction; |
161 factory_methods[keys::kAddResponseHeaderType] = | 291 factory_methods[keys::kAddResponseHeaderType] = |
162 &CreateAddResponseHeaderAction; | 292 &CreateAddResponseHeaderAction; |
163 factory_methods[keys::kCancelRequestType] = | 293 factory_methods[keys::kCancelRequestType] = |
164 &CallConstructorFactoryMethod<WebRequestCancelAction>; | 294 &CallConstructorFactoryMethod<WebRequestCancelAction>; |
| 295 factory_methods[keys::kEditRequestCookieType] = |
| 296 &CreateRequestCookieAction; |
| 297 factory_methods[keys::kEditResponseCookieType] = |
| 298 &CreateResponseCookieAction; |
165 factory_methods[keys::kRedirectByRegExType] = | 299 factory_methods[keys::kRedirectByRegExType] = |
166 &CreateRedirectRequestByRegExAction; | 300 &CreateRedirectRequestByRegExAction; |
167 factory_methods[keys::kRedirectRequestType] = | 301 factory_methods[keys::kRedirectRequestType] = |
168 &CreateRedirectRequestAction; | 302 &CreateRedirectRequestAction; |
169 factory_methods[keys::kRedirectToTransparentImageType] = | 303 factory_methods[keys::kRedirectToTransparentImageType] = |
170 &CallConstructorFactoryMethod< | 304 &CallConstructorFactoryMethod< |
171 WebRequestRedirectToTransparentImageAction>; | 305 WebRequestRedirectToTransparentImageAction>; |
172 factory_methods[keys::kRedirectToEmptyDocumentType] = | 306 factory_methods[keys::kRedirectToEmptyDocumentType] = |
173 &CallConstructorFactoryMethod<WebRequestRedirectToEmptyDocumentAction>; | 307 &CallConstructorFactoryMethod<WebRequestRedirectToEmptyDocumentAction>; |
| 308 factory_methods[keys::kRemoveRequestCookieType] = |
| 309 &CreateRequestCookieAction; |
| 310 factory_methods[keys::kRemoveResponseCookieType] = |
| 311 &CreateResponseCookieAction; |
174 factory_methods[keys::kSetRequestHeaderType] = | 312 factory_methods[keys::kSetRequestHeaderType] = |
175 &CreateSetRequestHeaderAction; | 313 &CreateSetRequestHeaderAction; |
176 factory_methods[keys::kRemoveRequestHeaderType] = | 314 factory_methods[keys::kRemoveRequestHeaderType] = |
177 &CreateRemoveRequestHeaderAction; | 315 &CreateRemoveRequestHeaderAction; |
178 factory_methods[keys::kRemoveResponseHeaderType] = | 316 factory_methods[keys::kRemoveResponseHeaderType] = |
179 &CreateRemoveResponseHeaderAction; | 317 &CreateRemoveResponseHeaderAction; |
180 factory_methods[keys::kIgnoreRulesType] = | 318 factory_methods[keys::kIgnoreRulesType] = |
181 &CreateIgnoreRulesAction; | 319 &CreateIgnoreRulesAction; |
182 } | 320 } |
183 }; | 321 }; |
(...skipping 571 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
755 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta( | 893 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta( |
756 net::URLRequest* request, | 894 net::URLRequest* request, |
757 RequestStages request_stage, | 895 RequestStages request_stage, |
758 const WebRequestRule::OptionalRequestData& optional_request_data, | 896 const WebRequestRule::OptionalRequestData& optional_request_data, |
759 const std::string& extension_id, | 897 const std::string& extension_id, |
760 const base::Time& extension_install_time) const { | 898 const base::Time& extension_install_time) const { |
761 CHECK(request_stage & GetStages()); | 899 CHECK(request_stage & GetStages()); |
762 return LinkedPtrEventResponseDelta(NULL); | 900 return LinkedPtrEventResponseDelta(NULL); |
763 } | 901 } |
764 | 902 |
| 903 // |
| 904 // WebRequestRequestCookieAction |
| 905 // |
| 906 |
| 907 WebRequestRequestCookieAction::WebRequestRequestCookieAction( |
| 908 linked_ptr<RequestCookieModification> request_cookie_modification) |
| 909 : request_cookie_modification_(request_cookie_modification) { |
| 910 CHECK(request_cookie_modification_.get()); |
| 911 } |
| 912 |
| 913 WebRequestRequestCookieAction::~WebRequestRequestCookieAction() {} |
| 914 |
| 915 int WebRequestRequestCookieAction::GetStages() const { |
| 916 return ON_BEFORE_SEND_HEADERS; |
| 917 } |
| 918 |
| 919 WebRequestAction::Type WebRequestRequestCookieAction::GetType() const { |
| 920 return WebRequestAction::ACTION_MODIFY_REQUEST_COOKIE; |
| 921 } |
| 922 |
| 923 LinkedPtrEventResponseDelta WebRequestRequestCookieAction::CreateDelta( |
| 924 net::URLRequest* request, |
| 925 RequestStages request_stage, |
| 926 const WebRequestRule::OptionalRequestData& optional_request_data, |
| 927 const std::string& extension_id, |
| 928 const base::Time& extension_install_time) const { |
| 929 CHECK(request_stage & GetStages()); |
| 930 LinkedPtrEventResponseDelta result( |
| 931 new extension_web_request_api_helpers::EventResponseDelta( |
| 932 extension_id, extension_install_time)); |
| 933 result->request_cookie_modifications.push_back( |
| 934 request_cookie_modification_); |
| 935 return result; |
| 936 } |
| 937 |
| 938 // |
| 939 // WebRequestResponseCookieAction |
| 940 // |
| 941 |
| 942 WebRequestResponseCookieAction::WebRequestResponseCookieAction( |
| 943 linked_ptr<ResponseCookieModification> response_cookie_modification) |
| 944 : response_cookie_modification_(response_cookie_modification) { |
| 945 CHECK(response_cookie_modification_.get()); |
| 946 } |
| 947 |
| 948 WebRequestResponseCookieAction::~WebRequestResponseCookieAction() {} |
| 949 |
| 950 int WebRequestResponseCookieAction::GetStages() const { |
| 951 return ON_HEADERS_RECEIVED; |
| 952 } |
| 953 |
| 954 WebRequestAction::Type WebRequestResponseCookieAction::GetType() const { |
| 955 return WebRequestAction::ACTION_MODIFY_RESPONSE_COOKIE; |
| 956 } |
| 957 |
| 958 LinkedPtrEventResponseDelta WebRequestResponseCookieAction::CreateDelta( |
| 959 net::URLRequest* request, |
| 960 RequestStages request_stage, |
| 961 const WebRequestRule::OptionalRequestData& optional_request_data, |
| 962 const std::string& extension_id, |
| 963 const base::Time& extension_install_time) const { |
| 964 CHECK(request_stage & GetStages()); |
| 965 LinkedPtrEventResponseDelta result( |
| 966 new extension_web_request_api_helpers::EventResponseDelta( |
| 967 extension_id, extension_install_time)); |
| 968 result->response_cookie_modifications.push_back( |
| 969 response_cookie_modification_); |
| 970 return result; |
| 971 } |
| 972 |
765 } // namespace extensions | 973 } // namespace extensions |
OLD | NEW |