Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(276)

Side by Side Diff: extensions/browser/api/declarative_webrequest/webrequest_action.cc

Issue 598173003: Run clang-modernize -use-nullptr over src/extensions/. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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_, &current_value)) { 972 while (headers->EnumerateHeader(&iter, name_, &current_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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698