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 "extensions/browser/api/declarative_webrequest/webrequest_action.h" | 5 #include "extensions/browser/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 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
119 std::string* error, | 119 std::string* error, |
120 bool* bad_message) { | 120 bool* bad_message) { |
121 return scoped_refptr<const WebRequestAction>(new T); | 121 return scoped_refptr<const WebRequestAction>(new T); |
122 } | 122 } |
123 | 123 |
124 scoped_refptr<const WebRequestAction> CreateRedirectRequestAction( | 124 scoped_refptr<const WebRequestAction> CreateRedirectRequestAction( |
125 const std::string& instance_type, | 125 const std::string& instance_type, |
126 const base::Value* value, | 126 const base::Value* value, |
127 std::string* error, | 127 std::string* error, |
128 bool* bad_message) { | 128 bool* bad_message) { |
129 const base::DictionaryValue* dict = NULL; | 129 const base::DictionaryValue* dict = nullptr; |
130 CHECK(value->GetAsDictionary(&dict)); | 130 CHECK(value->GetAsDictionary(&dict)); |
131 std::string redirect_url_string; | 131 std::string redirect_url_string; |
132 INPUT_FORMAT_VALIDATE( | 132 INPUT_FORMAT_VALIDATE( |
133 dict->GetString(keys::kRedirectUrlKey, &redirect_url_string)); | 133 dict->GetString(keys::kRedirectUrlKey, &redirect_url_string)); |
134 GURL redirect_url(redirect_url_string); | 134 GURL redirect_url(redirect_url_string); |
135 return scoped_refptr<const WebRequestAction>( | 135 return scoped_refptr<const WebRequestAction>( |
136 new WebRequestRedirectAction(redirect_url)); | 136 new WebRequestRedirectAction(redirect_url)); |
137 } | 137 } |
138 | 138 |
139 scoped_refptr<const WebRequestAction> CreateRedirectRequestByRegExAction( | 139 scoped_refptr<const WebRequestAction> CreateRedirectRequestByRegExAction( |
140 const std::string& instance_type, | 140 const std::string& instance_type, |
141 const base::Value* value, | 141 const base::Value* value, |
142 std::string* error, | 142 std::string* error, |
143 bool* bad_message) { | 143 bool* bad_message) { |
144 const base::DictionaryValue* dict = NULL; | 144 const base::DictionaryValue* dict = nullptr; |
145 CHECK(value->GetAsDictionary(&dict)); | 145 CHECK(value->GetAsDictionary(&dict)); |
146 std::string from; | 146 std::string from; |
147 std::string to; | 147 std::string to; |
148 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kFromKey, &from)); | 148 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kFromKey, &from)); |
149 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kToKey, &to)); | 149 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kToKey, &to)); |
150 | 150 |
151 to = WebRequestRedirectByRegExAction::PerlToRe2Style(to); | 151 to = WebRequestRedirectByRegExAction::PerlToRe2Style(to); |
152 | 152 |
153 RE2::Options options; | 153 RE2::Options options; |
154 options.set_case_sensitive(false); | 154 options.set_case_sensitive(false); |
155 scoped_ptr<RE2> from_pattern(new RE2(from, options)); | 155 scoped_ptr<RE2> from_pattern(new RE2(from, options)); |
156 | 156 |
157 if (!from_pattern->ok()) { | 157 if (!from_pattern->ok()) { |
158 *error = "Invalid pattern '" + from + "' -> '" + to + "'"; | 158 *error = "Invalid pattern '" + from + "' -> '" + to + "'"; |
159 return scoped_refptr<const WebRequestAction>(NULL); | 159 return scoped_refptr<const WebRequestAction>(nullptr); |
160 } | 160 } |
161 return scoped_refptr<const WebRequestAction>( | 161 return scoped_refptr<const WebRequestAction>( |
162 new WebRequestRedirectByRegExAction(from_pattern.Pass(), to)); | 162 new WebRequestRedirectByRegExAction(from_pattern.Pass(), to)); |
163 } | 163 } |
164 | 164 |
165 scoped_refptr<const WebRequestAction> CreateSetRequestHeaderAction( | 165 scoped_refptr<const WebRequestAction> CreateSetRequestHeaderAction( |
166 const std::string& instance_type, | 166 const std::string& instance_type, |
167 const base::Value* json_value, | 167 const base::Value* json_value, |
168 std::string* error, | 168 std::string* error, |
169 bool* bad_message) { | 169 bool* bad_message) { |
170 const base::DictionaryValue* dict = NULL; | 170 const base::DictionaryValue* dict = nullptr; |
171 CHECK(json_value->GetAsDictionary(&dict)); | 171 CHECK(json_value->GetAsDictionary(&dict)); |
172 std::string name; | 172 std::string name; |
173 std::string value; | 173 std::string value; |
174 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); | 174 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); |
175 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kValueKey, &value)); | 175 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kValueKey, &value)); |
176 if (!net::HttpUtil::IsValidHeaderName(name)) { | 176 if (!net::HttpUtil::IsValidHeaderName(name)) { |
177 *error = extension_web_request_api_constants::kInvalidHeaderName; | 177 *error = extension_web_request_api_constants::kInvalidHeaderName; |
178 return scoped_refptr<const WebRequestAction>(NULL); | 178 return scoped_refptr<const WebRequestAction>(nullptr); |
179 } | 179 } |
180 if (!net::HttpUtil::IsValidHeaderValue(value)) { | 180 if (!net::HttpUtil::IsValidHeaderValue(value)) { |
181 *error = ErrorUtils::FormatErrorMessage( | 181 *error = ErrorUtils::FormatErrorMessage( |
182 extension_web_request_api_constants::kInvalidHeaderValue, name); | 182 extension_web_request_api_constants::kInvalidHeaderValue, name); |
183 return scoped_refptr<const WebRequestAction>(NULL); | 183 return scoped_refptr<const WebRequestAction>(nullptr); |
184 } | 184 } |
185 return scoped_refptr<const WebRequestAction>( | 185 return scoped_refptr<const WebRequestAction>( |
186 new WebRequestSetRequestHeaderAction(name, value)); | 186 new WebRequestSetRequestHeaderAction(name, value)); |
187 } | 187 } |
188 | 188 |
189 scoped_refptr<const WebRequestAction> CreateRemoveRequestHeaderAction( | 189 scoped_refptr<const WebRequestAction> CreateRemoveRequestHeaderAction( |
190 const std::string& instance_type, | 190 const std::string& instance_type, |
191 const base::Value* value, | 191 const base::Value* value, |
192 std::string* error, | 192 std::string* error, |
193 bool* bad_message) { | 193 bool* bad_message) { |
194 const base::DictionaryValue* dict = NULL; | 194 const base::DictionaryValue* dict = nullptr; |
195 CHECK(value->GetAsDictionary(&dict)); | 195 CHECK(value->GetAsDictionary(&dict)); |
196 std::string name; | 196 std::string name; |
197 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); | 197 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); |
198 if (!net::HttpUtil::IsValidHeaderName(name)) { | 198 if (!net::HttpUtil::IsValidHeaderName(name)) { |
199 *error = extension_web_request_api_constants::kInvalidHeaderName; | 199 *error = extension_web_request_api_constants::kInvalidHeaderName; |
200 return scoped_refptr<const WebRequestAction>(NULL); | 200 return scoped_refptr<const WebRequestAction>(nullptr); |
201 } | 201 } |
202 return scoped_refptr<const WebRequestAction>( | 202 return scoped_refptr<const WebRequestAction>( |
203 new WebRequestRemoveRequestHeaderAction(name)); | 203 new WebRequestRemoveRequestHeaderAction(name)); |
204 } | 204 } |
205 | 205 |
206 scoped_refptr<const WebRequestAction> CreateAddResponseHeaderAction( | 206 scoped_refptr<const WebRequestAction> CreateAddResponseHeaderAction( |
207 const std::string& instance_type, | 207 const std::string& instance_type, |
208 const base::Value* json_value, | 208 const base::Value* json_value, |
209 std::string* error, | 209 std::string* error, |
210 bool* bad_message) { | 210 bool* bad_message) { |
211 const base::DictionaryValue* dict = NULL; | 211 const base::DictionaryValue* dict = nullptr; |
212 CHECK(json_value->GetAsDictionary(&dict)); | 212 CHECK(json_value->GetAsDictionary(&dict)); |
213 std::string name; | 213 std::string name; |
214 std::string value; | 214 std::string value; |
215 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); | 215 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); |
216 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kValueKey, &value)); | 216 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kValueKey, &value)); |
217 if (!net::HttpUtil::IsValidHeaderName(name)) { | 217 if (!net::HttpUtil::IsValidHeaderName(name)) { |
218 *error = extension_web_request_api_constants::kInvalidHeaderName; | 218 *error = extension_web_request_api_constants::kInvalidHeaderName; |
219 return scoped_refptr<const WebRequestAction>(NULL); | 219 return scoped_refptr<const WebRequestAction>(nullptr); |
220 } | 220 } |
221 if (!net::HttpUtil::IsValidHeaderValue(value)) { | 221 if (!net::HttpUtil::IsValidHeaderValue(value)) { |
222 *error = ErrorUtils::FormatErrorMessage( | 222 *error = ErrorUtils::FormatErrorMessage( |
223 extension_web_request_api_constants::kInvalidHeaderValue, name); | 223 extension_web_request_api_constants::kInvalidHeaderValue, name); |
224 return scoped_refptr<const WebRequestAction>(NULL); | 224 return scoped_refptr<const WebRequestAction>(nullptr); |
225 } | 225 } |
226 return scoped_refptr<const WebRequestAction>( | 226 return scoped_refptr<const WebRequestAction>( |
227 new WebRequestAddResponseHeaderAction(name, value)); | 227 new WebRequestAddResponseHeaderAction(name, value)); |
228 } | 228 } |
229 | 229 |
230 scoped_refptr<const WebRequestAction> CreateRemoveResponseHeaderAction( | 230 scoped_refptr<const WebRequestAction> CreateRemoveResponseHeaderAction( |
231 const std::string& instance_type, | 231 const std::string& instance_type, |
232 const base::Value* json_value, | 232 const base::Value* json_value, |
233 std::string* error, | 233 std::string* error, |
234 bool* bad_message) { | 234 bool* bad_message) { |
235 const base::DictionaryValue* dict = NULL; | 235 const base::DictionaryValue* dict = nullptr; |
236 CHECK(json_value->GetAsDictionary(&dict)); | 236 CHECK(json_value->GetAsDictionary(&dict)); |
237 std::string name; | 237 std::string name; |
238 std::string value; | 238 std::string value; |
239 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); | 239 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name)); |
240 bool has_value = dict->GetString(keys::kValueKey, &value); | 240 bool has_value = dict->GetString(keys::kValueKey, &value); |
241 if (!net::HttpUtil::IsValidHeaderName(name)) { | 241 if (!net::HttpUtil::IsValidHeaderName(name)) { |
242 *error = extension_web_request_api_constants::kInvalidHeaderName; | 242 *error = extension_web_request_api_constants::kInvalidHeaderName; |
243 return scoped_refptr<const WebRequestAction>(NULL); | 243 return scoped_refptr<const WebRequestAction>(nullptr); |
244 } | 244 } |
245 if (has_value && !net::HttpUtil::IsValidHeaderValue(value)) { | 245 if (has_value && !net::HttpUtil::IsValidHeaderValue(value)) { |
246 *error = ErrorUtils::FormatErrorMessage( | 246 *error = ErrorUtils::FormatErrorMessage( |
247 extension_web_request_api_constants::kInvalidHeaderValue, name); | 247 extension_web_request_api_constants::kInvalidHeaderValue, name); |
248 return scoped_refptr<const WebRequestAction>(NULL); | 248 return scoped_refptr<const WebRequestAction>(nullptr); |
249 } | 249 } |
250 return scoped_refptr<const WebRequestAction>( | 250 return scoped_refptr<const WebRequestAction>( |
251 new WebRequestRemoveResponseHeaderAction(name, value, has_value)); | 251 new WebRequestRemoveResponseHeaderAction(name, value, has_value)); |
252 } | 252 } |
253 | 253 |
254 scoped_refptr<const WebRequestAction> CreateIgnoreRulesAction( | 254 scoped_refptr<const WebRequestAction> CreateIgnoreRulesAction( |
255 const std::string& instance_type, | 255 const std::string& instance_type, |
256 const base::Value* value, | 256 const base::Value* value, |
257 std::string* error, | 257 std::string* error, |
258 bool* bad_message) { | 258 bool* bad_message) { |
259 const base::DictionaryValue* dict = NULL; | 259 const base::DictionaryValue* dict = nullptr; |
260 CHECK(value->GetAsDictionary(&dict)); | 260 CHECK(value->GetAsDictionary(&dict)); |
261 bool has_parameter = false; | 261 bool has_parameter = false; |
262 int minimum_priority = std::numeric_limits<int>::min(); | 262 int minimum_priority = std::numeric_limits<int>::min(); |
263 std::string ignore_tag; | 263 std::string ignore_tag; |
264 if (dict->HasKey(keys::kLowerPriorityThanKey)) { | 264 if (dict->HasKey(keys::kLowerPriorityThanKey)) { |
265 INPUT_FORMAT_VALIDATE( | 265 INPUT_FORMAT_VALIDATE( |
266 dict->GetInteger(keys::kLowerPriorityThanKey, &minimum_priority)); | 266 dict->GetInteger(keys::kLowerPriorityThanKey, &minimum_priority)); |
267 has_parameter = true; | 267 has_parameter = true; |
268 } | 268 } |
269 if (dict->HasKey(keys::kHasTagKey)) { | 269 if (dict->HasKey(keys::kHasTagKey)) { |
270 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kHasTagKey, &ignore_tag)); | 270 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kHasTagKey, &ignore_tag)); |
271 has_parameter = true; | 271 has_parameter = true; |
272 } | 272 } |
273 if (!has_parameter) { | 273 if (!has_parameter) { |
274 *error = kIgnoreRulesRequiresParameterError; | 274 *error = kIgnoreRulesRequiresParameterError; |
275 return scoped_refptr<const WebRequestAction>(NULL); | 275 return scoped_refptr<const WebRequestAction>(nullptr); |
276 } | 276 } |
277 return scoped_refptr<const WebRequestAction>( | 277 return scoped_refptr<const WebRequestAction>( |
278 new WebRequestIgnoreRulesAction(minimum_priority, ignore_tag)); | 278 new WebRequestIgnoreRulesAction(minimum_priority, ignore_tag)); |
279 } | 279 } |
280 | 280 |
281 scoped_refptr<const WebRequestAction> CreateRequestCookieAction( | 281 scoped_refptr<const WebRequestAction> CreateRequestCookieAction( |
282 const std::string& instance_type, | 282 const std::string& instance_type, |
283 const base::Value* value, | 283 const base::Value* value, |
284 std::string* error, | 284 std::string* error, |
285 bool* bad_message) { | 285 bool* bad_message) { |
286 using extension_web_request_api_helpers::RequestCookieModification; | 286 using extension_web_request_api_helpers::RequestCookieModification; |
287 | 287 |
288 const base::DictionaryValue* dict = NULL; | 288 const base::DictionaryValue* dict = nullptr; |
289 CHECK(value->GetAsDictionary(&dict)); | 289 CHECK(value->GetAsDictionary(&dict)); |
290 | 290 |
291 linked_ptr<RequestCookieModification> modification( | 291 linked_ptr<RequestCookieModification> modification( |
292 new RequestCookieModification); | 292 new RequestCookieModification); |
293 | 293 |
294 // Get modification type. | 294 // Get modification type. |
295 if (instance_type == keys::kAddRequestCookieType) | 295 if (instance_type == keys::kAddRequestCookieType) |
296 modification->type = helpers::ADD; | 296 modification->type = helpers::ADD; |
297 else if (instance_type == keys::kEditRequestCookieType) | 297 else if (instance_type == keys::kEditRequestCookieType) |
298 modification->type = helpers::EDIT; | 298 modification->type = helpers::EDIT; |
299 else if (instance_type == keys::kRemoveRequestCookieType) | 299 else if (instance_type == keys::kRemoveRequestCookieType) |
300 modification->type = helpers::REMOVE; | 300 modification->type = helpers::REMOVE; |
301 else | 301 else |
302 INPUT_FORMAT_VALIDATE(false); | 302 INPUT_FORMAT_VALIDATE(false); |
303 | 303 |
304 // Get filter. | 304 // Get filter. |
305 if (modification->type == helpers::EDIT || | 305 if (modification->type == helpers::EDIT || |
306 modification->type == helpers::REMOVE) { | 306 modification->type == helpers::REMOVE) { |
307 const base::DictionaryValue* filter = NULL; | 307 const base::DictionaryValue* filter = nullptr; |
308 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter)); | 308 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter)); |
309 modification->filter = ParseRequestCookie(filter); | 309 modification->filter = ParseRequestCookie(filter); |
310 } | 310 } |
311 | 311 |
312 // Get new value. | 312 // Get new value. |
313 if (modification->type == helpers::ADD) { | 313 if (modification->type == helpers::ADD) { |
314 const base::DictionaryValue* value = NULL; | 314 const base::DictionaryValue* value = nullptr; |
315 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value)); | 315 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value)); |
316 modification->modification = ParseRequestCookie(value); | 316 modification->modification = ParseRequestCookie(value); |
317 } else if (modification->type == helpers::EDIT) { | 317 } else if (modification->type == helpers::EDIT) { |
318 const base::DictionaryValue* value = NULL; | 318 const base::DictionaryValue* value = nullptr; |
319 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value)); | 319 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value)); |
320 modification->modification = ParseRequestCookie(value); | 320 modification->modification = ParseRequestCookie(value); |
321 } | 321 } |
322 | 322 |
323 return scoped_refptr<const WebRequestAction>( | 323 return scoped_refptr<const WebRequestAction>( |
324 new WebRequestRequestCookieAction(modification)); | 324 new WebRequestRequestCookieAction(modification)); |
325 } | 325 } |
326 | 326 |
327 scoped_refptr<const WebRequestAction> CreateResponseCookieAction( | 327 scoped_refptr<const WebRequestAction> CreateResponseCookieAction( |
328 const std::string& instance_type, | 328 const std::string& instance_type, |
329 const base::Value* value, | 329 const base::Value* value, |
330 std::string* error, | 330 std::string* error, |
331 bool* bad_message) { | 331 bool* bad_message) { |
332 using extension_web_request_api_helpers::ResponseCookieModification; | 332 using extension_web_request_api_helpers::ResponseCookieModification; |
333 | 333 |
334 const base::DictionaryValue* dict = NULL; | 334 const base::DictionaryValue* dict = nullptr; |
335 CHECK(value->GetAsDictionary(&dict)); | 335 CHECK(value->GetAsDictionary(&dict)); |
336 | 336 |
337 linked_ptr<ResponseCookieModification> modification( | 337 linked_ptr<ResponseCookieModification> modification( |
338 new ResponseCookieModification); | 338 new ResponseCookieModification); |
339 | 339 |
340 // Get modification type. | 340 // Get modification type. |
341 if (instance_type == keys::kAddResponseCookieType) | 341 if (instance_type == keys::kAddResponseCookieType) |
342 modification->type = helpers::ADD; | 342 modification->type = helpers::ADD; |
343 else if (instance_type == keys::kEditResponseCookieType) | 343 else if (instance_type == keys::kEditResponseCookieType) |
344 modification->type = helpers::EDIT; | 344 modification->type = helpers::EDIT; |
345 else if (instance_type == keys::kRemoveResponseCookieType) | 345 else if (instance_type == keys::kRemoveResponseCookieType) |
346 modification->type = helpers::REMOVE; | 346 modification->type = helpers::REMOVE; |
347 else | 347 else |
348 INPUT_FORMAT_VALIDATE(false); | 348 INPUT_FORMAT_VALIDATE(false); |
349 | 349 |
350 // Get filter. | 350 // Get filter. |
351 if (modification->type == helpers::EDIT || | 351 if (modification->type == helpers::EDIT || |
352 modification->type == helpers::REMOVE) { | 352 modification->type == helpers::REMOVE) { |
353 const base::DictionaryValue* filter = NULL; | 353 const base::DictionaryValue* filter = nullptr; |
354 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter)); | 354 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter)); |
355 modification->filter = ParseFilterResponseCookie(filter); | 355 modification->filter = ParseFilterResponseCookie(filter); |
356 } | 356 } |
357 | 357 |
358 // Get new value. | 358 // Get new value. |
359 if (modification->type == helpers::ADD) { | 359 if (modification->type == helpers::ADD) { |
360 const base::DictionaryValue* value = NULL; | 360 const base::DictionaryValue* value = nullptr; |
361 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value)); | 361 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value)); |
362 modification->modification = ParseResponseCookie(value); | 362 modification->modification = ParseResponseCookie(value); |
363 } else if (modification->type == helpers::EDIT) { | 363 } else if (modification->type == helpers::EDIT) { |
364 const base::DictionaryValue* value = NULL; | 364 const base::DictionaryValue* value = nullptr; |
365 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value)); | 365 INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value)); |
366 modification->modification = ParseResponseCookie(value); | 366 modification->modification = ParseResponseCookie(value); |
367 } | 367 } |
368 | 368 |
369 return scoped_refptr<const WebRequestAction>( | 369 return scoped_refptr<const WebRequestAction>( |
370 new WebRequestResponseCookieAction(modification)); | 370 new WebRequestResponseCookieAction(modification)); |
371 } | 371 } |
372 | 372 |
373 scoped_refptr<const WebRequestAction> CreateSendMessageToExtensionAction( | 373 scoped_refptr<const WebRequestAction> CreateSendMessageToExtensionAction( |
374 const std::string& name, | 374 const std::string& name, |
375 const base::Value* value, | 375 const base::Value* value, |
376 std::string* error, | 376 std::string* error, |
377 bool* bad_message) { | 377 bool* bad_message) { |
378 const base::DictionaryValue* dict = NULL; | 378 const base::DictionaryValue* dict = nullptr; |
379 CHECK(value->GetAsDictionary(&dict)); | 379 CHECK(value->GetAsDictionary(&dict)); |
380 std::string message; | 380 std::string message; |
381 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kMessageKey, &message)); | 381 INPUT_FORMAT_VALIDATE(dict->GetString(keys::kMessageKey, &message)); |
382 return scoped_refptr<const WebRequestAction>( | 382 return scoped_refptr<const WebRequestAction>( |
383 new WebRequestSendMessageToExtensionAction(message)); | 383 new WebRequestSendMessageToExtensionAction(message)); |
384 } | 384 } |
385 | 385 |
386 struct WebRequestActionFactory { | 386 struct WebRequestActionFactory { |
387 DedupingFactory<WebRequestAction> factory; | 387 DedupingFactory<WebRequestAction> factory; |
388 | 388 |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
514 // static | 514 // static |
515 scoped_refptr<const WebRequestAction> WebRequestAction::Create( | 515 scoped_refptr<const WebRequestAction> WebRequestAction::Create( |
516 content::BrowserContext* browser_context, | 516 content::BrowserContext* browser_context, |
517 const Extension* extension, | 517 const Extension* extension, |
518 const base::Value& json_action, | 518 const base::Value& json_action, |
519 std::string* error, | 519 std::string* error, |
520 bool* bad_message) { | 520 bool* bad_message) { |
521 *error = ""; | 521 *error = ""; |
522 *bad_message = false; | 522 *bad_message = false; |
523 | 523 |
524 const base::DictionaryValue* action_dict = NULL; | 524 const base::DictionaryValue* action_dict = nullptr; |
525 INPUT_FORMAT_VALIDATE(json_action.GetAsDictionary(&action_dict)); | 525 INPUT_FORMAT_VALIDATE(json_action.GetAsDictionary(&action_dict)); |
526 | 526 |
527 std::string instance_type; | 527 std::string instance_type; |
528 INPUT_FORMAT_VALIDATE( | 528 INPUT_FORMAT_VALIDATE( |
529 action_dict->GetString(keys::kInstanceTypeKey, &instance_type)); | 529 action_dict->GetString(keys::kInstanceTypeKey, &instance_type)); |
530 | 530 |
531 WebRequestActionFactory& factory = g_web_request_action_factory.Get(); | 531 WebRequestActionFactory& factory = g_web_request_action_factory.Get(); |
532 return factory.factory.Instantiate( | 532 return factory.factory.Instantiate( |
533 instance_type, action_dict, error, bad_message); | 533 instance_type, action_dict, error, bad_message); |
534 } | 534 } |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
613 std::string WebRequestRedirectAction::GetName() const { | 613 std::string WebRequestRedirectAction::GetName() const { |
614 return keys::kRedirectRequestType; | 614 return keys::kRedirectRequestType; |
615 } | 615 } |
616 | 616 |
617 LinkedPtrEventResponseDelta WebRequestRedirectAction::CreateDelta( | 617 LinkedPtrEventResponseDelta WebRequestRedirectAction::CreateDelta( |
618 const WebRequestData& request_data, | 618 const WebRequestData& request_data, |
619 const std::string& extension_id, | 619 const std::string& extension_id, |
620 const base::Time& extension_install_time) const { | 620 const base::Time& extension_install_time) const { |
621 CHECK(request_data.stage & stages()); | 621 CHECK(request_data.stage & stages()); |
622 if (request_data.request->url() == redirect_url_) | 622 if (request_data.request->url() == redirect_url_) |
623 return LinkedPtrEventResponseDelta(NULL); | 623 return LinkedPtrEventResponseDelta(nullptr); |
624 LinkedPtrEventResponseDelta result( | 624 LinkedPtrEventResponseDelta result( |
625 new helpers::EventResponseDelta(extension_id, extension_install_time)); | 625 new helpers::EventResponseDelta(extension_id, extension_install_time)); |
626 result->new_url = redirect_url_; | 626 result->new_url = redirect_url_; |
627 return result; | 627 return result; |
628 } | 628 } |
629 | 629 |
630 // | 630 // |
631 // WebRequestRedirectToTransparentImageAction | 631 // WebRequestRedirectToTransparentImageAction |
632 // | 632 // |
633 | 633 |
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
774 const WebRequestData& request_data, | 774 const WebRequestData& request_data, |
775 const std::string& extension_id, | 775 const std::string& extension_id, |
776 const base::Time& extension_install_time) const { | 776 const base::Time& extension_install_time) const { |
777 CHECK(request_data.stage & stages()); | 777 CHECK(request_data.stage & stages()); |
778 CHECK(from_pattern_.get()); | 778 CHECK(from_pattern_.get()); |
779 | 779 |
780 const std::string& old_url = request_data.request->url().spec(); | 780 const std::string& old_url = request_data.request->url().spec(); |
781 std::string new_url = old_url; | 781 std::string new_url = old_url; |
782 if (!RE2::Replace(&new_url, *from_pattern_, to_pattern_) || | 782 if (!RE2::Replace(&new_url, *from_pattern_, to_pattern_) || |
783 new_url == old_url) { | 783 new_url == old_url) { |
784 return LinkedPtrEventResponseDelta(NULL); | 784 return LinkedPtrEventResponseDelta(nullptr); |
785 } | 785 } |
786 | 786 |
787 LinkedPtrEventResponseDelta result( | 787 LinkedPtrEventResponseDelta result( |
788 new extension_web_request_api_helpers::EventResponseDelta( | 788 new extension_web_request_api_helpers::EventResponseDelta( |
789 extension_id, extension_install_time)); | 789 extension_id, extension_install_time)); |
790 result->new_url = GURL(new_url); | 790 result->new_url = GURL(new_url); |
791 return result; | 791 return result; |
792 } | 792 } |
793 | 793 |
794 // | 794 // |
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
903 | 903 |
904 LinkedPtrEventResponseDelta | 904 LinkedPtrEventResponseDelta |
905 WebRequestAddResponseHeaderAction::CreateDelta( | 905 WebRequestAddResponseHeaderAction::CreateDelta( |
906 const WebRequestData& request_data, | 906 const WebRequestData& request_data, |
907 const std::string& extension_id, | 907 const std::string& extension_id, |
908 const base::Time& extension_install_time) const { | 908 const base::Time& extension_install_time) const { |
909 CHECK(request_data.stage & stages()); | 909 CHECK(request_data.stage & stages()); |
910 const net::HttpResponseHeaders* headers = | 910 const net::HttpResponseHeaders* headers = |
911 request_data.original_response_headers; | 911 request_data.original_response_headers; |
912 if (!headers) | 912 if (!headers) |
913 return LinkedPtrEventResponseDelta(NULL); | 913 return LinkedPtrEventResponseDelta(nullptr); |
914 | 914 |
915 // Don't generate the header if it exists already. | 915 // Don't generate the header if it exists already. |
916 if (headers->HasHeaderValue(name_, value_)) | 916 if (headers->HasHeaderValue(name_, value_)) |
917 return LinkedPtrEventResponseDelta(NULL); | 917 return LinkedPtrEventResponseDelta(nullptr); |
918 | 918 |
919 LinkedPtrEventResponseDelta result( | 919 LinkedPtrEventResponseDelta result( |
920 new helpers::EventResponseDelta(extension_id, extension_install_time)); | 920 new helpers::EventResponseDelta(extension_id, extension_install_time)); |
921 result->added_response_headers.push_back(make_pair(name_, value_)); | 921 result->added_response_headers.push_back(make_pair(name_, value_)); |
922 return result; | 922 return result; |
923 } | 923 } |
924 | 924 |
925 // | 925 // |
926 // WebRequestRemoveResponseHeaderAction | 926 // WebRequestRemoveResponseHeaderAction |
927 // | 927 // |
(...skipping 28 matching lines...) Expand all Loading... |
956 | 956 |
957 LinkedPtrEventResponseDelta | 957 LinkedPtrEventResponseDelta |
958 WebRequestRemoveResponseHeaderAction::CreateDelta( | 958 WebRequestRemoveResponseHeaderAction::CreateDelta( |
959 const WebRequestData& request_data, | 959 const WebRequestData& request_data, |
960 const std::string& extension_id, | 960 const std::string& extension_id, |
961 const base::Time& extension_install_time) const { | 961 const base::Time& extension_install_time) const { |
962 CHECK(request_data.stage & stages()); | 962 CHECK(request_data.stage & stages()); |
963 const net::HttpResponseHeaders* headers = | 963 const net::HttpResponseHeaders* headers = |
964 request_data.original_response_headers; | 964 request_data.original_response_headers; |
965 if (!headers) | 965 if (!headers) |
966 return LinkedPtrEventResponseDelta(NULL); | 966 return LinkedPtrEventResponseDelta(nullptr); |
967 | 967 |
968 LinkedPtrEventResponseDelta result( | 968 LinkedPtrEventResponseDelta result( |
969 new helpers::EventResponseDelta(extension_id, extension_install_time)); | 969 new helpers::EventResponseDelta(extension_id, extension_install_time)); |
970 void* iter = NULL; | 970 void* iter = nullptr; |
971 std::string current_value; | 971 std::string current_value; |
972 while (headers->EnumerateHeader(&iter, name_, ¤t_value)) { | 972 while (headers->EnumerateHeader(&iter, name_, ¤t_value)) { |
973 if (has_value_ && | 973 if (has_value_ && |
974 (current_value.size() != value_.size() || | 974 (current_value.size() != value_.size() || |
975 !std::equal(current_value.begin(), current_value.end(), | 975 !std::equal(current_value.begin(), current_value.end(), |
976 value_.begin(), | 976 value_.begin(), |
977 base::CaseInsensitiveCompare<char>()))) { | 977 base::CaseInsensitiveCompare<char>()))) { |
978 continue; | 978 continue; |
979 } | 979 } |
980 result->deleted_response_headers.push_back(make_pair(name_, current_value)); | 980 result->deleted_response_headers.push_back(make_pair(name_, current_value)); |
(...skipping 28 matching lines...) Expand all Loading... |
1009 | 1009 |
1010 std::string WebRequestIgnoreRulesAction::GetName() const { | 1010 std::string WebRequestIgnoreRulesAction::GetName() const { |
1011 return keys::kIgnoreRulesType; | 1011 return keys::kIgnoreRulesType; |
1012 } | 1012 } |
1013 | 1013 |
1014 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta( | 1014 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta( |
1015 const WebRequestData& request_data, | 1015 const WebRequestData& request_data, |
1016 const std::string& extension_id, | 1016 const std::string& extension_id, |
1017 const base::Time& extension_install_time) const { | 1017 const base::Time& extension_install_time) const { |
1018 CHECK(request_data.stage & stages()); | 1018 CHECK(request_data.stage & stages()); |
1019 return LinkedPtrEventResponseDelta(NULL); | 1019 return LinkedPtrEventResponseDelta(nullptr); |
1020 } | 1020 } |
1021 | 1021 |
1022 // | 1022 // |
1023 // WebRequestRequestCookieAction | 1023 // WebRequestRequestCookieAction |
1024 // | 1024 // |
1025 | 1025 |
1026 WebRequestRequestCookieAction::WebRequestRequestCookieAction( | 1026 WebRequestRequestCookieAction::WebRequestRequestCookieAction( |
1027 linked_ptr<RequestCookieModification> request_cookie_modification) | 1027 linked_ptr<RequestCookieModification> request_cookie_modification) |
1028 : WebRequestAction(ON_BEFORE_SEND_HEADERS, | 1028 : WebRequestAction(ON_BEFORE_SEND_HEADERS, |
1029 ACTION_MODIFY_REQUEST_COOKIE, | 1029 ACTION_MODIFY_REQUEST_COOKIE, |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1160 const base::Time& extension_install_time) const { | 1160 const base::Time& extension_install_time) const { |
1161 CHECK(request_data.stage & stages()); | 1161 CHECK(request_data.stage & stages()); |
1162 LinkedPtrEventResponseDelta result( | 1162 LinkedPtrEventResponseDelta result( |
1163 new extension_web_request_api_helpers::EventResponseDelta( | 1163 new extension_web_request_api_helpers::EventResponseDelta( |
1164 extension_id, extension_install_time)); | 1164 extension_id, extension_install_time)); |
1165 result->messages_to_extension.insert(message_); | 1165 result->messages_to_extension.insert(message_); |
1166 return result; | 1166 return result; |
1167 } | 1167 } |
1168 | 1168 |
1169 } // namespace extensions | 1169 } // namespace extensions |
OLD | NEW |