Add base:: to string16 in extensions/.

extensions/browser/admin_policy.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 "extensions/browser/admin_policy.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 bool ManagementPolicyImpl(const extensions::Extension* extension,
-                          string16* error,
+                          base::string16* error,
                           bool modifiable_value) {
   bool modifiable =
       extension->location() != extensions::Manifest::COMPONENT &&
       !extensions::Manifest::IsPolicyLocation(extension->location());
   // Some callers equate "no restriction" to true, others to false.
   if (modifiable)
     return modifiable_value;
 
   if (error) {
     *error = l10n_util::GetStringFUTF16(
         IDS_EXTENSION_CANT_MODIFY_POLICY_REQUIRED,
         UTF8ToUTF16(extension->name()));
   }
   return !modifiable_value;
 }
 
-bool ReturnLoadError(const extensions::Extension* extension, string16* error) {
+bool ReturnLoadError(const extensions::Extension* extension,
+                     base::string16* error) {
   if (error) {
     *error = l10n_util::GetStringFUTF16(
           IDS_EXTENSION_CANT_INSTALL_POLICY_BLOCKED,
           UTF8ToUTF16(extension->name()),
           UTF8ToUTF16(extension->id()));
   }
   return false;
 }
 
 }  // namespace
 
 namespace extensions {
 namespace admin_policy {
 
 bool BlacklistedByDefault(const base::ListValue* blacklist) {
   base::StringValue wildcard("*");
   return blacklist && blacklist->Find(wildcard) != blacklist->end();
 }
 
 bool UserMayLoad(const base::ListValue* blacklist,
                  const base::ListValue* whitelist,
                  const base::DictionaryValue* forcelist,
                  const base::ListValue* allowed_types,
                  const Extension* extension,
-                 string16* error) {
+                 base::string16* error) {
   // Component extensions are always allowed.
   if (extension->location() == Manifest::COMPONENT)
     return true;
 
   // Forced installed extensions cannot be overwritten manually.
   if (extension->location() != Manifest::EXTERNAL_POLICY &&
       extension->location() != Manifest::EXTERNAL_POLICY_DOWNLOAD &&
       forcelist && forcelist->HasKey(extension->id())) {
     return ReturnLoadError(extension, error);
   }
@@ skipping 33 matching lines @@
     return true;
 
   // Then check the admin blacklist.
   if ((blacklist && blacklist->Find(id_value) != blacklist->end()) ||
       BlacklistedByDefault(blacklist))
     return ReturnLoadError(extension, error);
 
   return true;
 }
 
-bool UserMayModifySettings(const Extension* extension, string16* error) {
+bool UserMayModifySettings(const Extension* extension, base::string16* error) {
   return ManagementPolicyImpl(extension, error, true);
 }
 
-bool MustRemainEnabled(const Extension* extension, string16* error) {
+bool MustRemainEnabled(const Extension* extension, base::string16* error) {
   return ManagementPolicyImpl(extension, error, false);
 }
 
 }  // namespace admin_policy
 }  // namespace extensions