Blink Rename follow-up: URLs --big-rename--> _ur_ls --this-fix--> _urls.

third_party/WebKit/Source/core/editing/serializers/Serialization.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008, 2009, 2010, 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011 Igalia S.L.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 227 matching lines @@
 }
 
 template <typename Strategy>
 class CreateMarkupAlgorithm {
  public:
   static String CreateMarkup(
       const PositionTemplate<Strategy>& start_position,
       const PositionTemplate<Strategy>& end_position,
       EAnnotateForInterchange should_annotate = kDoNotAnnotateForInterchange,
       ConvertBlocksToInlines = ConvertBlocksToInlines::kNotConvert,
-      EAbsoluteURLs should_resolve_ur_ls = kDoNotResolveURLs,
+      EAbsoluteURLs should_resolve_urls = kDoNotResolveURLs,
       Node* constraining_ancestor = nullptr);
 };
 
 // FIXME: Shouldn't we omit style info when annotate ==
 // DoNotAnnotateForInterchange?
 // FIXME: At least, annotation and style info should probably not be included in
 // range.markupString()
 template <typename Strategy>
 String CreateMarkupAlgorithm<Strategy>::CreateMarkup(
     const PositionTemplate<Strategy>& start_position,
     const PositionTemplate<Strategy>& end_position,
     EAnnotateForInterchange should_annotate,
     ConvertBlocksToInlines convert_blocks_to_inlines,
-    EAbsoluteURLs should_resolve_ur_ls,
+    EAbsoluteURLs should_resolve_urls,
     Node* constraining_ancestor) {
   if (start_position.IsNull() || end_position.IsNull())
     return g_empty_string;
 
   CHECK_LE(start_position.CompareTo(end_position), 0);
 
   bool collapsed = start_position == end_position;
   if (collapsed)
     return g_empty_string;
   Node* common_ancestor =
       Strategy::CommonAncestor(*start_position.ComputeContainerNode(),
                                *end_position.ComputeContainerNode());
   if (!common_ancestor)
     return g_empty_string;
 
   Document* document = start_position.GetDocument();
 
   DCHECK(!document->NeedsLayoutTreeUpdate());
   DocumentLifecycle::DisallowTransitionScope disallow_transition(
       document->Lifecycle());
 
   HTMLElement* special_common_ancestor = HighestAncestorToWrapMarkup<Strategy>(
       start_position, end_position, should_annotate, constraining_ancestor);
   StyledMarkupSerializer<Strategy> serializer(
-      should_resolve_ur_ls, should_annotate, start_position, end_position,
+      should_resolve_urls, should_annotate, start_position, end_position,
       special_common_ancestor, convert_blocks_to_inlines);
   return serializer.CreateMarkup();
 }
 
 String CreateMarkup(const Position& start_position,
                     const Position& end_position,
                     EAnnotateForInterchange should_annotate,
                     ConvertBlocksToInlines convert_blocks_to_inlines,
-                    EAbsoluteURLs should_resolve_ur_ls,
+                    EAbsoluteURLs should_resolve_urls,
                     Node* constraining_ancestor) {
   return CreateMarkupAlgorithm<EditingStrategy>::CreateMarkup(
       start_position, end_position, should_annotate, convert_blocks_to_inlines,
-      should_resolve_ur_ls, constraining_ancestor);
+      should_resolve_urls, constraining_ancestor);
 }
 
 String CreateMarkup(const PositionInFlatTree& start_position,
                     const PositionInFlatTree& end_position,
                     EAnnotateForInterchange should_annotate,
                     ConvertBlocksToInlines convert_blocks_to_inlines,
-                    EAbsoluteURLs should_resolve_ur_ls,
+                    EAbsoluteURLs should_resolve_urls,
                     Node* constraining_ancestor) {
   return CreateMarkupAlgorithm<EditingInFlatTreeStrategy>::CreateMarkup(
       start_position, end_position, should_annotate, convert_blocks_to_inlines,
-      should_resolve_ur_ls, constraining_ancestor);
+      should_resolve_urls, constraining_ancestor);
 }
 
 DocumentFragment* CreateFragmentFromMarkup(
     Document& document,
     const String& markup,
     const String& base_url,
     ParserContentPolicy parser_content_policy) {
   // We use a fake body element here to trick the HTML parser to using the
   // InBody insertion mode.
   HTMLBodyElement* fake_body = HTMLBodyElement::Create(document);
@@ skipping 105 matching lines @@
   else
     fragment->ParserTakeAllChildrenFrom(ToContainerNode(*common_ancestor));
 
   TrimFragment(fragment, node_before_context, node_after_context);
 
   return fragment;
 }
 
 String CreateMarkup(const Node* node,
                     EChildrenOnly children_only,
-                    EAbsoluteURLs should_resolve_ur_ls) {
+                    EAbsoluteURLs should_resolve_urls) {
   if (!node)
     return "";
 
-  MarkupAccumulator accumulator(should_resolve_ur_ls);
+  MarkupAccumulator accumulator(should_resolve_urls);
   return SerializeNodes<EditingStrategy>(accumulator, const_cast<Node&>(*node),
                                          children_only);
 }
 
 static void FillContainerFromString(ContainerNode* paragraph,
                                     const String& string) {
   Document& document = paragraph->GetDocument();
 
   if (string.IsEmpty()) {
     paragraph->AppendChild(HTMLBRElement::Create(document));
@@ skipping 305 matching lines @@
   text_node->appendData(text_next->data());
   if (text_next->parentNode())  // Might have been removed by mutation event.
     text_next->remove(exception_state);
 }
 
 template class CORE_TEMPLATE_EXPORT CreateMarkupAlgorithm<EditingStrategy>;
 template class CORE_TEMPLATE_EXPORT
     CreateMarkupAlgorithm<EditingInFlatTreeStrategy>;
 
 }  // namespace blink