Convert string16 to base::string16 in content.

content/common/handle_enumerator_win.cc

 // Copyright (c) 2011 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 "content/common/handle_enumerator_win.h"
 
 #include <windows.h>
 #include <map>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/process/process.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "sandbox/win/src/handle_table.h"
 
 namespace content {
 namespace {
 
-typedef std::map<const string16, HandleType> HandleTypeMap;
+typedef std::map<const base::string16, HandleType> HandleTypeMap;
 
 HandleTypeMap& MakeHandleTypeMap() {
   HandleTypeMap& handle_types = *(new HandleTypeMap());
   handle_types[sandbox::HandleTable::kTypeProcess] = ProcessHandle;
   handle_types[sandbox::HandleTable::kTypeThread] = ThreadHandle;
   handle_types[sandbox::HandleTable::kTypeFile] = FileHandle;
   handle_types[sandbox::HandleTable::kTypeDirectory] = DirectoryHandle;
   handle_types[sandbox::HandleTable::kTypeKey] = KeyHandle;
   handle_types[sandbox::HandleTable::kTypeWindowStation] = WindowStationHandle;
   handle_types[sandbox::HandleTable::kTypeDesktop] = DesktopHandle;
@@ skipping 12 matching lines @@
 
 }  // namespace
 
 const size_t kMaxHandleNameLength = 1024;
 
 void HandleEnumerator::EnumerateHandles() {
   sandbox::HandleTable handles;
   std::string process_type =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessType);
-  string16 output = ASCIIToUTF16(process_type);
+  base::string16 output = ASCIIToUTF16(process_type);
   output.append(ASCIIToUTF16(" process - Handles at shutdown:\n"));
   for (sandbox::HandleTable::Iterator sys_handle
       = handles.HandlesForProcess(::GetCurrentProcessId());
       sys_handle != handles.end(); ++sys_handle) {
     HandleType current_type = StringToHandleType(sys_handle->Type());
     if (!all_handles_ && (current_type != ProcessHandle &&
                           current_type != FileHandle &&
                           current_type != DirectoryHandle &&
                           current_type != KeyHandle &&
                           current_type != WindowStationHandle &&
                           current_type != DesktopHandle &&
                           current_type != ServiceHandle))
       continue;
 
     output += ASCIIToUTF16("[");
     output += sys_handle->Type();
     output += ASCIIToUTF16("] (");
     output += sys_handle->Name();
     output += ASCIIToUTF16(")\n");
     output += GetAccessString(current_type,
         sys_handle->handle_entry()->GrantedAccess);
   }
   DVLOG(0) << output;
 }
 
-HandleType StringToHandleType(const string16& type) {
+HandleType StringToHandleType(const base::string16& type) {
   static HandleTypeMap handle_types = MakeHandleTypeMap();
   HandleTypeMap::iterator result = handle_types.find(type);
   return result != handle_types.end() ? result->second : OtherHandle;
 }
 
-string16 GetAccessString(HandleType handle_type,
+base::string16 GetAccessString(HandleType handle_type,
                                            ACCESS_MASK access) {
-  string16 output;
+  base::string16 output;
   if (access & GENERIC_READ)
     output.append(ASCIIToUTF16("\tGENERIC_READ\n"));
   if (access & GENERIC_WRITE)
     output.append(ASCIIToUTF16("\tGENERIC_WRITE\n"));
   if (access & GENERIC_EXECUTE)
     output.append(ASCIIToUTF16("\tGENERIC_EXECUTE\n"));
   if (access & GENERIC_ALL)
     output.append(ASCIIToUTF16("\tGENERIC_ALL\n"));
   if (access & DELETE)
     output.append(ASCIIToUTF16("\tDELETE\n"));
@@ skipping 211 matching lines @@
       if (access & FILE_MAP_READ)
         output.append(ASCIIToUTF16("\tFILE_MAP_READ\n"));
       if (access & FILE_MAP_WRITE)
         output.append(ASCIIToUTF16("\tFILE_MAP_WRITE\n"));
       break;
   }
   return output;
 }
 
 }  // namespace content