Use base namespace for string16 in chrome/renderer.

chrome/renderer/web_apps.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 "chrome/renderer/web_apps.h"
 
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
@@ skipping 22 matching lines @@
 using blink::WebFrame;
 using blink::WebNode;
 using blink::WebNodeList;
 using blink::WebString;
 
 namespace web_apps {
 namespace {
 
 // Sizes a single size (the width or height) from a 'sizes' attribute. A size
 // matches must match the following regex: [1-9][0-9]*.
-int ParseSingleIconSize(const string16& text) {
+int ParseSingleIconSize(const base::string16& text) {
   // Size must not start with 0, and be between 0 and 9.
   if (text.empty() || !(text[0] >= L'1' && text[0] <= L'9'))
     return 0;
 
   // Make sure all chars are from 0-9.
   for (size_t i = 1; i < text.length(); ++i) {
     if (!(text[i] >= L'0' && text[i] <= L'9'))
       return 0;
   }
   int output;
   if (!base::StringToInt(text, &output))
     return 0;
   return output;
 }
 
 // Parses an icon size. An icon size must match the following regex:
 // [1-9][0-9]*x[1-9][0-9]*.
 // If the input couldn't be parsed, a size with a width/height == 0 is returned.
-gfx::Size ParseIconSize(const string16& text) {
-  std::vector<string16> sizes;
+gfx::Size ParseIconSize(const base::string16& text) {
+  std::vector<base::string16> sizes;
   base::SplitStringDontTrim(text, L'x', &sizes);
   if (sizes.size() != 2)
     return gfx::Size();
 
   return gfx::Size(ParseSingleIconSize(sizes[0]),
                    ParseSingleIconSize(sizes[1]));
 }
 
 void AddInstallIcon(const WebElement& link,
                     std::vector<WebApplicationInfo::IconInfo>* icons) {
@@ skipping 15 matching lines @@
       icon_sizes.size() == 1) {
     icon_info.width = icon_sizes[0].width();
     icon_info.height = icon_sizes[0].height();
   }
   icon_info.url = url;
   icons->push_back(icon_info);
 }
 
 }  // namespace
 
-bool ParseIconSizes(const string16& text,
+bool ParseIconSizes(const base::string16& text,
                     std::vector<gfx::Size>* sizes,
                     bool* is_any) {
   *is_any = false;
-  std::vector<string16> size_strings;
+  std::vector<base::string16> size_strings;
   base::SplitStringAlongWhitespace(text, &size_strings);
   for (size_t i = 0; i < size_strings.size(); ++i) {
     if (EqualsASCII(size_strings[i], "any")) {
       *is_any = true;
     } else {
       gfx::Size size = ParseIconSize(size_strings[i]);
       if (size.width() <= 0 || size.height() <= 0)
         return false;  // Bogus size.
       sizes->push_back(size);
     }
   }
   if (*is_any && !sizes->empty()) {
     // If is_any is true, it must occur by itself.
     return false;
   }
   return (*is_any || !sizes->empty());
 }
 
 bool ParseWebAppFromWebDocument(WebFrame* frame,
                                 WebApplicationInfo* app_info,
-                                string16* error) {
+                                base::string16* error) {
   WebDocument document = frame->document();
   if (document.isNull())
     return true;
 
   WebElement head = document.head();
   if (head.isNull())
     return true;
 
   GURL document_url = document.url();
   WebNodeList children = head.childNodes();
@@ skipping 27 matching lines @@
         if (!app_info->app_url.is_valid())
           app_info->app_url = GURL();
       }
     }
   }
 
   return true;
 }
 
 }  // namespace web_apps