Remove 'using base::string16;' from base/strings/string16.h and remove temporary

base/test/test_process_killer_win.cc

 // Copyright (c) 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 "base/test/test_process_killer_win.h"
 
 #include <windows.h>
 #include <winternl.h>
 
 #include <algorithm>
@@ skipping 20 matching lines @@
   static NtQueryInformationProcess* qip_func =
       reinterpret_cast<NtQueryInformationProcess*>(
           GetProcAddress(GetModuleHandle(L"ntdll.dll"),
           "NtQueryInformationProcess"));
   DCHECK(qip_func) << "Could not get pointer to NtQueryInformationProcess.";
   *qip_func_ptr = qip_func;
   return qip_func != NULL;
 }
 
 // Get the command line of a process
-bool GetCommandLineForProcess(uint32 process_id, string16* cmd_line) {
+bool GetCommandLineForProcess(uint32 process_id, base::string16* cmd_line) {
   DCHECK(process_id != 0);
   DCHECK(cmd_line);
 
   // Open the process
   base::win::ScopedHandle process_handle(::OpenProcess(
       PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
       false,
       process_id));
   if (!process_handle) {
     DLOG(ERROR) << "Failed to open process " << process_id << ", last error = "
@@ skipping 34 matching lines @@
                                sizeof(process_params_address),
                                &bytes_read)) {
         DLOG(ERROR) << "Failed to read process params address, last error = "
                     << GetLastError();
       }
     }
   }
 
   // Copy all the process parameters into a buffer.
   bool success = false;
-  string16 buffer;
+  base::string16 buffer;
   if (process_params_address) {
     SIZE_T bytes_read;
     RTL_USER_PROCESS_PARAMETERS params = { 0 };
     if (!::ReadProcessMemory(process_handle.Get(),
                              reinterpret_cast<void*>(process_params_address),
                              &params,
                              sizeof(params),
                              &bytes_read)) {
       DLOG(ERROR) << "Failed to read RTL_USER_PROCESS_PARAMETERS, "
                   << "last error = " << GetLastError();
@@ skipping 16 matching lines @@
       }
     }
   }
 
   return success;
 }
 
 // Used to filter processes by process ID.
 class ArgumentFilter : public base::ProcessFilter {
  public:
-  explicit ArgumentFilter(const string16& argument)
+  explicit ArgumentFilter(const base::string16& argument)
       : argument_to_find_(argument) {}
 
   // Returns true to indicate set-inclusion and false otherwise.  This method
   // should not have side-effects and should be idempotent.
   virtual bool Includes(const base::ProcessEntry& entry) const {
     bool found = false;
-    string16 command_line;
+    base::string16 command_line;
     if (GetCommandLineForProcess(entry.pid(), &command_line)) {
-      string16::const_iterator it =
+      base::string16::const_iterator it =
           std::search(command_line.begin(),
                       command_line.end(),
                       argument_to_find_.begin(),
                       argument_to_find_.end(),
-          base::CaseInsensitiveCompareASCII<wchar_t>());
+                      base::CaseInsensitiveCompareASCII<wchar_t>());
       found = (it != command_line.end());
     }
     return found;
   }
 
  protected:
-  string16 argument_to_find_;
+  base::string16 argument_to_find_;
 };
 
 }  // namespace
 
 namespace base {
 
 bool KillAllNamedProcessesWithArgument(const string16& process_name,
                                        const string16& argument) {
   ArgumentFilter argument_filter(argument);
   return base::KillProcesses(process_name, 0, &argument_filter);
 }
 
 }  // namespace base