Add base:: to string16 in rlz/.

rlz/test/rlz_test_helpers.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.
 //
 // Main entry point for all unit tests.
 
 #include "rlz_test_helpers.h"
 
 #include <map>
 #include <vector>
@@ skipping 15 matching lines @@
 
 namespace {
 
 // Path to recursively copy into the replacemment hives.  These are needed
 // to make sure certain win32 APIs continue to run correctly once the real
 // hives are replaced.
 const wchar_t kHKLMAccessProviders[] =
     L"System\\CurrentControlSet\\Control\\Lsa\\AccessProviders";
 
 struct RegistryValue {
-  string16 name;
+  base::string16 name;
   DWORD type;
   std::vector<uint8> data;
 };
 
 struct RegistryKeyData {
   std::vector<RegistryValue> values;
-  std::map<string16, RegistryKeyData> keys;
+  std::map<base::string16, RegistryKeyData> keys;
 };
 
 void ReadRegistryTree(const base::win::RegKey& src, RegistryKeyData* data) {
   // First read values.
   {
     base::win::RegistryValueIterator i(src.Handle(), L"");
     data->values.clear();
     data->values.reserve(i.ValueCount());
     for (; i.Valid(); ++i) {
       RegistryValue& value = *data->values.insert(data->values.end(),
                                                   RegistryValue());
       const uint8* data = reinterpret_cast<const uint8*>(i.Value());
       value.name.assign(i.Name());
       value.type = i.Type();
       value.data.assign(data, data + i.ValueSize());
     }
   }
 
   // Next read subkeys recursively.
   for (base::win::RegistryKeyIterator i(src.Handle(), L"");
        i.Valid(); ++i) {
     ReadRegistryTree(base::win::RegKey(src.Handle(), i.Name(), KEY_READ),
-                     &data->keys[string16(i.Name())]);
+                     &data->keys[base::string16(i.Name())]);
   }
 }
 
 void WriteRegistryTree(const RegistryKeyData& data, base::win::RegKey* dest) {
   // First write values.
   for (size_t i = 0; i < data.values.size(); ++i) {
     const RegistryValue& value = data.values[i];
     dest->WriteValue(value.name.c_str(),
                      value.data.size() ? &value.data[0] : NULL,
                      static_cast<DWORD>(value.data.size()),
                      value.type);
   }
 
   // Next write values recursively.
-  for (std::map<string16, RegistryKeyData>::const_iterator iter =
+  for (std::map<base::string16, RegistryKeyData>::const_iterator iter =
            data.keys.begin();
        iter != data.keys.end(); ++iter) {
     WriteRegistryTree(iter->second,
                       &base::win::RegKey(dest->Handle(), iter->first.c_str(),
                                          KEY_ALL_ACCESS));
   }
 }
 
 // Initialize temporary HKLM/HKCU registry hives used for testing.
 // Testing RLZ requires reading and writing to the Windows registry.  To keep
@@ skipping 51 matching lines @@
   rlz_lib::testing::SetRlzStoreDirectory(base::FilePath());
 #endif  // defined(OS_POSIX)
 }
 
 void RlzLibTestBase::SetUp() {
   RlzLibTestNoMachineState::SetUp();
 #if defined(OS_WIN)
   rlz_lib::CreateMachineState();
 #endif  // defined(OS_WIN)
 }