Renamed namespaces in src/net.

net/base/net_util_icu.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/net_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/i18n/time_formatting.h"
@@ skipping 391 matching lines @@
 
       // Need to add the dot we just found (if we found one).
       if (component_end < input16.length())
         out16.push_back('.');
     }
   }
   return out16;
 }
 
 // If |component| is valid, its begin is incremented by |delta|.
-void AdjustComponent(int delta, url_parse::Component* component) {
+void AdjustComponent(int delta, url::Component* component) {
   if (!component->is_valid())
     return;
 
   DCHECK(delta >= 0 || component->begin >= -delta);
   component->begin += delta;
 }
 
 // Adjusts all the components of |parsed| by |delta|, except for the scheme.
-void AdjustAllComponentsButScheme(int delta, url_parse::Parsed* parsed) {
+void AdjustAllComponentsButScheme(int delta, url::Parsed* parsed) {
   AdjustComponent(delta, &(parsed->username));
   AdjustComponent(delta, &(parsed->password));
   AdjustComponent(delta, &(parsed->host));
   AdjustComponent(delta, &(parsed->port));
   AdjustComponent(delta, &(parsed->path));
   AdjustComponent(delta, &(parsed->query));
   AdjustComponent(delta, &(parsed->ref));
 }
 
 // Helper for FormatUrlWithOffsets().
 base::string16 FormatViewSourceUrl(
     const GURL& url,
     const std::string& languages,
     FormatUrlTypes format_types,
     UnescapeRule::Type unescape_rules,
-    url_parse::Parsed* new_parsed,
+    url::Parsed* new_parsed,
     size_t* prefix_end,
     base::OffsetAdjuster::Adjustments* adjustments) {
   DCHECK(new_parsed);
   const char kViewSource[] = "view-source:";
   const size_t kViewSourceLength = arraysize(kViewSource) - 1;
 
   // Format the underlying URL and record adjustments.
   const std::string& url_str(url.possibly_invalid_spec());
   adjustments->clear();
   base::string16 result(base::ASCIIToUTF16(kViewSource) +
@@ skipping 72 matching lines @@
   const UnescapeRule::Type unescape_rules_;
 };
 
 // Transforms the portion of |spec| covered by |original_component| according to
 // |transform|.  Appends the result to |output|.  If |output_component| is
 // non-NULL, its start and length are set to the transformed component's new
 // start and length.  If |adjustments| is non-NULL, appends adjustments (if
 // any) that reflect the transformation the original component underwent to
 // become the transformed value appended to |output|.
 void AppendFormattedComponent(const std::string& spec,
-                              const url_parse::Component& original_component,
+                              const url::Component& original_component,
                               const AppendComponentTransform& transform,
                               base::string16* output,
-                              url_parse::Component* output_component,
+                              url::Component* output_component,
                               base::OffsetAdjuster::Adjustments* adjustments) {
   DCHECK(output);
   if (original_component.is_nonempty()) {
     size_t original_component_begin =
         static_cast<size_t>(original_component.begin);
     size_t output_component_begin = output->length();
     std::string component_str(spec, original_component_begin,
                               static_cast<size_t>(original_component.len));
 
     // Transform |component_str| and modify |adjustments| appropriately.
@@ skipping 84 matching lines @@
   AppendFormattedComponent(url.possibly_invalid_spec(),
       url.parsed_for_possibly_invalid_spec().host,
       HostComponentTransform(languages), output, NULL, NULL);
 }
 
 base::string16 FormatUrlWithOffsets(
     const GURL& url,
     const std::string& languages,
     FormatUrlTypes format_types,
     UnescapeRule::Type unescape_rules,
-    url_parse::Parsed* new_parsed,
+    url::Parsed* new_parsed,
     size_t* prefix_end,
     std::vector<size_t>* offsets_for_adjustment) {
   base::OffsetAdjuster::Adjustments adjustments;
   const base::string16& format_url_return_value =
       FormatUrlWithAdjustments(url, languages, format_types, unescape_rules,
                                new_parsed, prefix_end, &adjustments);
   base::OffsetAdjuster::AdjustOffsets(adjustments, offsets_for_adjustment);
   if (offsets_for_adjustment) {
     std::for_each(
         offsets_for_adjustment->begin(),
         offsets_for_adjustment->end(),
         base::LimitOffset<std::string>(format_url_return_value.length()));
   }
   return format_url_return_value;
 }
 
 base::string16 FormatUrlWithAdjustments(
     const GURL& url,
     const std::string& languages,
     FormatUrlTypes format_types,
     UnescapeRule::Type unescape_rules,
-    url_parse::Parsed* new_parsed,
+    url::Parsed* new_parsed,
     size_t* prefix_end,
     base::OffsetAdjuster::Adjustments* adjustments) {
   DCHECK(adjustments != NULL);
   adjustments->clear();
-  url_parse::Parsed parsed_temp;
+  url::Parsed parsed_temp;
   if (!new_parsed)
     new_parsed = &parsed_temp;
   else
-    *new_parsed = url_parse::Parsed();
+    *new_parsed = url::Parsed();
 
   // Special handling for view-source:.  Don't use content::kViewSourceScheme
   // because this library shouldn't depend on chrome.
   const char* const kViewSource = "view-source";
   // Reject "view-source:view-source:..." to avoid deep recursion.
   const char* const kViewSourceTwice = "view-source:view-source:";
   if (url.SchemeIs(kViewSource) &&
       !StartsWithASCII(url.possibly_invalid_spec(), kViewSourceTwice, false)) {
     return FormatViewSourceUrl(url, languages, format_types,
                                unescape_rules, new_parsed, prefix_end,
                                adjustments);
   }
 
   // We handle both valid and invalid URLs (this will give us the spec
   // regardless of validity).
   const std::string& spec = url.possibly_invalid_spec();
-  const url_parse::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
+  const url::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
 
   // Scheme & separators.  These are ASCII.
   base::string16 url_string;
   url_string.insert(
       url_string.end(), spec.begin(),
-      spec.begin() + parsed.CountCharactersBefore(url_parse::Parsed::USERNAME,
-                                                  true));
+      spec.begin() + parsed.CountCharactersBefore(url::Parsed::USERNAME, true));
   const char kHTTP[] = "http://";
   const char kFTP[] = "ftp.";
   // URLFixerUpper::FixupURL() treats "ftp.foo.com" as ftp://ftp.foo.com.  This
   // means that if we trim "http://" off a URL whose host starts with "ftp." and
   // the user inputs this into any field subject to fixup (which is basically
   // all input fields), the meaning would be changed.  (In fact, often the
   // formatted URL is directly pre-filled into an input field.)  For this reason
   // we avoid stripping "http://" in this case.
   bool omit_http = (format_types & kFormatUrlOmitHTTP) &&
       EqualsASCII(url_string, kHTTP) &&
@@ skipping 10 matching lines @@
     // Update the adjustments based on removed username and/or password.
     if (parsed.username.is_nonempty() || parsed.password.is_nonempty()) {
       if (parsed.username.is_nonempty() && parsed.password.is_nonempty()) {
         // The seeming off-by-two is to account for the ':' after the username
         // and '@' after the password.
         adjustments->push_back(base::OffsetAdjuster::Adjustment(
             static_cast<size_t>(parsed.username.begin),
             static_cast<size_t>(parsed.username.len + parsed.password.len + 2),
             0));
       } else {
-        const url_parse::Component* nonempty_component =
+        const url::Component* nonempty_component =
             parsed.username.is_nonempty() ? &parsed.username : &parsed.password;
         // The seeming off-by-one is to account for the '@' after the
         // username/password.
         adjustments->push_back(base::OffsetAdjuster::Adjustment(
             static_cast<size_t>(nonempty_component->begin),
             static_cast<size_t>(nonempty_component->len + 1),
             0));
       }
     }
   } else {
@@ skipping 73 matching lines @@
     AdjustAllComponentsButScheme(delta, new_parsed);
   }
 
   return url_string;
 }
 
 base::string16 FormatUrl(const GURL& url,
                          const std::string& languages,
                          FormatUrlTypes format_types,
                          UnescapeRule::Type unescape_rules,
-                         url_parse::Parsed* new_parsed,
+                         url::Parsed* new_parsed,
                          size_t* prefix_end,
                          size_t* offset_for_adjustment) {
   Offsets offsets;
   if (offset_for_adjustment)
     offsets.push_back(*offset_for_adjustment);
   base::string16 result = FormatUrlWithOffsets(url, languages, format_types,
       unescape_rules, new_parsed, prefix_end, &offsets);
   if (offset_for_adjustment)
     *offset_for_adjustment = offsets[0];
   return result;
 }
 
 }  // namespace net