Add explicit base namespace to string16 users.

chrome/common/extensions/command.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/common/extensions/command.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 29 matching lines @@
   return accelerator != values::kKeyMediaNextTrack &&
          accelerator != values::kKeyMediaPlayPause &&
          accelerator != values::kKeyMediaPrevTrack &&
          accelerator != values::kKeyMediaStop;
 }
 
 ui::Accelerator ParseImpl(const std::string& accelerator,
                           const std::string& platform_key,
                           int index,
                           bool should_parse_media_keys,
-                          string16* error) {
+                          base::string16* error) {
   error->clear();
   if (platform_key != values::kKeybindingPlatformWin &&
       platform_key != values::kKeybindingPlatformMac &&
       platform_key != values::kKeybindingPlatformChromeOs &&
       platform_key != values::kKeybindingPlatformLinux &&
       platform_key != values::kKeybindingPlatformDefault) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBindingUnknownPlatform,
         base::IntToString(index),
         platform_key);
@@ skipping 187 matching lines @@
       tokens[i] = values::kKeyCtrl;
   }
   return JoinString(tokens, '+');
 }
 
 }  // namespace
 
 Command::Command() : global_(false) {}
 
 Command::Command(const std::string& command_name,
-                 const string16& description,
+                 const base::string16& description,
                  const std::string& accelerator,
                  bool global)
     : command_name_(command_name),
       description_(description),
       global_(global) {
-  string16 error;
+  base::string16 error;
   accelerator_ = ParseImpl(accelerator, CommandPlatform(), 0,
                            IsNamedCommand(command_name), &error);
 }
 
 Command::~Command() {}
 
 // static
 std::string Command::CommandPlatform() {
 #if defined(OS_WIN)
   return values::kKeybindingPlatformWin;
 #elif defined(OS_MACOSX)
   return values::kKeybindingPlatformMac;
 #elif defined(OS_CHROMEOS)
   return values::kKeybindingPlatformChromeOs;
 #elif defined(OS_LINUX)
   return values::kKeybindingPlatformLinux;
 #else
   return "";
 #endif
 }
 
 // static
 ui::Accelerator Command::StringToAccelerator(const std::string& accelerator,
                                              const std::string& command_name) {
-  string16 error;
+  base::string16 error;
   ui::Accelerator parsed =
       ParseImpl(accelerator, Command::CommandPlatform(), 0,
                 IsNamedCommand(command_name), &error);
   return parsed;
 }
 
 // static
 std::string Command::AcceleratorToString(const ui::Accelerator& accelerator) {
   std::string shortcut;
 
@@ skipping 77 matching lines @@
       default:
         return "";
     }
   }
   return shortcut;
 }
 
 bool Command::Parse(const base::DictionaryValue* command,
                     const std::string& command_name,
                     int index,
-                    string16* error) {
+                    base::string16* error) {
   DCHECK(!command_name.empty());
 
-  string16 description;
+  base::string16 description;
   if (IsNamedCommand(command_name)) {
     if (!command->GetString(keys::kDescription, &description) ||
         description.empty()) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBindingDescription,
           base::IntToString(index));
       return false;
     }
   }
 
@@ skipping 106 matching lines @@
       global_ = global;
     }
   }
   return true;
 }
 
 base::DictionaryValue* Command::ToValue(const Extension* extension,
                                         bool active) const {
   base::DictionaryValue* extension_data = new base::DictionaryValue();
 
-  string16 command_description;
+  base::string16 command_description;
   bool extension_action = false;
   if (command_name() == values::kBrowserActionCommandEvent ||
       command_name() == values::kPageActionCommandEvent ||
       command_name() == values::kScriptBadgeCommandEvent) {
     command_description =
         l10n_util::GetStringUTF16(IDS_EXTENSION_COMMANDS_GENERIC_ACTIVATE);
     extension_action = true;
   } else {
     command_description = description();
   }
@@ skipping 10 matching lines @@
     // dev and will be removed when we launch.
     static bool stable_or_beta =
         chrome::VersionInfo::GetChannel() >= chrome::VersionInfo::CHANNEL_BETA;
     extension_data->SetBoolean("scope_ui_visible", !stable_or_beta);
   }
 
   return extension_data;
 }
 
 }  // namespace extensions