Add explicit base namespace to string16 users.

chrome/common/extensions/manifest_handlers/app_launch_info.cc

 // Copyright 2013 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/common/extensions/manifest_handlers/app_launch_info.h"
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/manifest_constants.h"
 
 namespace extensions {
 
 namespace keys = manifest_keys;
 namespace values = manifest_values;
 namespace errors = manifest_errors;
 
 namespace {
 
 bool ReadLaunchDimension(const extensions::Manifest* manifest,
                          const char* key,
                          int* target,
                          bool is_valid_container,
-                         string16* error) {
+                         base::string16* error) {
   const Value* temp = NULL;
   if (manifest->Get(key, &temp)) {
     if (!is_valid_container) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValueContainer,
           key);
       return false;
     }
     if (!temp->GetAsInteger(target) || *target < 0) {
       *target = 0;
@@ skipping 56 matching lines @@
 
 // static
 GURL AppLaunchInfo::GetFullLaunchURL(const Extension* extension) {
   const AppLaunchInfo& info = GetAppLaunchInfo(extension);
   if (info.launch_local_path_.empty())
     return info.launch_web_url_;
   else
     return extension->url().Resolve(info.launch_local_path_);
 }
 
-bool AppLaunchInfo::Parse(Extension* extension, string16* error) {
+bool AppLaunchInfo::Parse(Extension* extension, base::string16* error) {
   if (!LoadLaunchURL(extension, error) ||
       !LoadLaunchContainer(extension, error))
     return false;
   return true;
 }
 
-bool AppLaunchInfo::LoadLaunchURL(Extension* extension, string16* error) {
+bool AppLaunchInfo::LoadLaunchURL(Extension* extension, base::string16* error) {
   const Value* temp = NULL;
 
   // Launch URL can be either local (to chrome-extension:// root) or an absolute
   // web URL.
   if (extension->manifest()->Get(keys::kLaunchLocalPath, &temp)) {
     if (extension->manifest()->Get(keys::kLaunchWebURL, NULL)) {
       *error = ASCIIToUTF16(errors::kLaunchPathAndURLAreExclusive);
       return false;
     }
 
@@ skipping 93 matching lines @@
       GURL cloud_print_enable_connector_url =
           cloud_print_service_url.ReplaceComponents(replacements);
       OverrideLaunchURL(extension, cloud_print_enable_connector_url);
     }
   }
 
   return true;
 }
 
 bool AppLaunchInfo::LoadLaunchContainer(Extension* extension,
-                                        string16* error) {
+                                        base::string16* error) {
   const Value* tmp_launcher_container = NULL;
   if (!extension->manifest()->Get(keys::kLaunchContainer,
                                   &tmp_launcher_container))
     return true;
 
   std::string launch_container_string;
   if (!tmp_launcher_container->GetAsString(&launch_container_string)) {
     *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
@@ skipping 53 matching lines @@
   pattern.SetPath(pattern.path() + '*');
   extension->AddWebExtentPattern(pattern);
 }
 
 AppLaunchManifestHandler::AppLaunchManifestHandler() {
 }
 
 AppLaunchManifestHandler::~AppLaunchManifestHandler() {
 }
 
-bool AppLaunchManifestHandler::Parse(Extension* extension, string16* error) {
+bool AppLaunchManifestHandler::Parse(Extension* extension,
+                                     base::string16* error) {
   scoped_ptr<AppLaunchInfo> info(new AppLaunchInfo);
   if (!info->Parse(extension, error))
     return false;
   extension->SetManifestData(keys::kLaunch, info.release());
   return true;
 }
 
 bool AppLaunchManifestHandler::AlwaysParseForType(Manifest::Type type) const {
   return type == Manifest::TYPE_LEGACY_PACKAGED_APP;
 }
 
 const std::vector<std::string> AppLaunchManifestHandler::Keys() const {
   static const char* keys[] = {
     keys::kLaunchLocalPath,
     keys::kLaunchWebURL,
     keys::kLaunchContainer,
     keys::kLaunchHeight,
     keys::kLaunchWidth
   };
   return std::vector<std::string>(keys, keys + arraysize(keys));
 }
 
 }  // namespace extensions