Add base:: to string16s in chrome/.

chrome/utility/importer/ie_importer_win.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/utility/importer/ie_importer_win.h"
 
 #include <ole2.h>
 #include <intshcut.h>
 #include <shlobj.h>
 #include <urlhist.h>
@@ skipping 40 matching lines @@
 const char16 kIEVersionKey[] =
   L"Software\\Microsoft\\Internet Explorer";
 const char16 kIEToolbarKey[] =
   L"Software\\Microsoft\\Internet Explorer\\Toolbar";
 
 // NTFS stream name of favicon image data.
 const char16 kFaviconStreamName[] = L":favicon:$DATA";
 
 // A struct that hosts the information of AutoComplete data in PStore.
 struct AutoCompleteInfo {
-  string16 key;
-  std::vector<string16> data;
+  base::string16 key;
+  std::vector<base::string16> data;
   bool is_url;
 };
 
 // Gets the creation time of the given file or directory.
-base::Time GetFileCreationTime(const string16& file) {
+base::Time GetFileCreationTime(const base::string16& file) {
   base::Time creation_time;
   base::win::ScopedHandle file_handle(
       CreateFile(file.c_str(), GENERIC_READ,
                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                  NULL, OPEN_EXISTING,
                  FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL));
   FILETIME creation_filetime;
   if (GetFileTime(file_handle, &creation_filetime, NULL, NULL))
     creation_time = base::Time::FromFileTime(creation_filetime);
   return creation_time;
@@ skipping 181 matching lines @@
   std::map<base::FilePath, uint32> sort_index;
   if (!ParseFavoritesOrderInfo(importer, &sort_index))
     return;
   IEOrderBookmarkComparator compare = {&sort_index};
   std::sort(bookmarks->begin(), bookmarks->end(), compare);
 }
 
 // Reads an internet shortcut (*.url) |file| and returns a COM object
 // representing it.
 bool LoadInternetShortcut(
-    const string16& file,
+    const base::string16& file,
     base::win::ScopedComPtr<IUniformResourceLocator>* shortcut) {
   base::win::ScopedComPtr<IUniformResourceLocator> url_locator;
   if (FAILED(url_locator.CreateInstance(CLSID_InternetShortcut, NULL,
                                         CLSCTX_INPROC_SERVER)))
     return false;
 
   base::win::ScopedComPtr<IPersistFile> persist_file;
   if (FAILED(persist_file.QueryFrom(url_locator)))
     return false;
 
@@ skipping 33 matching lines @@
   // ReadMultiple can return S_FALSE (FAILED(S_FALSE) is false) when the
   // property is not found, in which case output[0].vt is set to VT_EMPTY.
   if (FAILED(property_storage->ReadMultiple(1, properties, output.Receive())) ||
       output.get().vt != VT_LPWSTR)
     return GURL();
   return GURL(WideToUTF16(output.get().pwszVal));
 }
 
 // Reads the favicon imaga data in an NTFS alternate data stream. This is where
 // IE7 and above store the data.
-bool ReadFaviconDataFromInternetShortcut(const string16& file,
+bool ReadFaviconDataFromInternetShortcut(const base::string16& file,
                                          std::string* data) {
   return base::ReadFileToString(
       base::FilePath(file + kFaviconStreamName), data);
 }
 
 // Reads the favicon imaga data in the Internet cache. IE6 doesn't hold the data
 // explicitly, but it might be found in the cache.
 bool ReadFaviconDataFromCache(const GURL& favicon_url, std::string* data) {
   std::wstring url_wstring(UTF8ToWide(favicon_url.spec()));
   DWORD info_size = 0;
   GetUrlCacheEntryInfoEx(url_wstring.c_str(), NULL, &info_size, NULL, NULL,
                          NULL, 0);
   if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
     return false;
 
   std::vector<char> buf(info_size);
   INTERNET_CACHE_ENTRY_INFO* cache =
       reinterpret_cast<INTERNET_CACHE_ENTRY_INFO*>(&buf[0]);
   if (!GetUrlCacheEntryInfoEx(url_wstring.c_str(), cache, &info_size, NULL,
                               NULL, NULL, 0)) {
     return false;
   }
   return base::ReadFileToString(base::FilePath(cache->lpszLocalFileName), data);
 }
 
 // Reads the binary image data of favicon of an internet shortcut file |file|.
 // |favicon_url| read by ReadFaviconURLFromInternetShortcut is also needed to
 // examine the IE cache.
-bool ReadReencodedFaviconData(const string16& file,
+bool ReadReencodedFaviconData(const base::string16& file,
                               const GURL& favicon_url,
                               std::vector<unsigned char>* data) {
   std::string image_data;
   if (!ReadFaviconDataFromInternetShortcut(file, &image_data) &&
       !ReadFaviconDataFromCache(favicon_url, &image_data)) {
     return false;
   }
 
   const unsigned char* ptr =
       reinterpret_cast<const unsigned char*>(image_data.c_str());
   return importer::ReencodeFavicon(ptr, image_data.size(), data);
 }
 
 // Loads favicon image data and registers to |favicon_map|.
-void UpdateFaviconMap(
-    const string16& url_file,
-    const GURL& url,
-    IUniformResourceLocator* url_locator,
-    std::map<GURL, ImportedFaviconUsage>* favicon_map) {
+void UpdateFaviconMap(const base::string16& url_file,
+                      const GURL& url,
+                      IUniformResourceLocator* url_locator,
+                      std::map<GURL, ImportedFaviconUsage>* favicon_map) {
   GURL favicon_url = ReadFaviconURLFromInternetShortcut(url_locator);
   if (!favicon_url.is_valid())
     return;
 
   std::map<GURL, ImportedFaviconUsage>::iterator it =
     favicon_map->find(favicon_url);
   if (it != favicon_map->end()) {
     // Known favicon URL.
     it->second.urls.insert(url);
   } else {
@@ skipping 71 matching lines @@
 void IEImporter::ImportFavorites() {
   FavoritesInfo info;
   if (!GetFavoritesInfo(&info))
     return;
 
   BookmarkVector bookmarks;
   std::vector<ImportedFaviconUsage> favicons;
   ParseFavoritesFolder(info, &bookmarks, &favicons);
 
   if (!bookmarks.empty() && !cancelled()) {
-    const string16& first_folder_name =
+    const base::string16& first_folder_name =
         l10n_util::GetStringUTF16(IDS_BOOKMARK_GROUP_FROM_IE);
     bridge_->AddBookmarks(bookmarks, first_folder_name);
   }
   if (!favicons.empty() && !cancelled())
     bridge_->SetFavicons(favicons);
 }
 
 void IEImporter::ImportHistory() {
   const std::string kSchemes[] = {content::kHttpScheme,
                                   content::kHttpsScheme,
                                   content::kFtpScheme,
                                   chrome::kFileScheme};
   int total_schemes = arraysize(kSchemes);
 
   base::win::ScopedComPtr<IUrlHistoryStg2> url_history_stg2;
   HRESULT result;
   result = url_history_stg2.CreateInstance(CLSID_CUrlHistory, NULL,
                                            CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return;
   base::win::ScopedComPtr<IEnumSTATURL> enum_url;
   if (SUCCEEDED(result = url_history_stg2->EnumUrls(enum_url.Receive()))) {
     std::vector<ImporterURLRow> rows;
     STATURL stat_url;
     ULONG fetched;
     while (!cancelled() &&
            (result = enum_url->Next(1, &stat_url, &fetched)) == S_OK) {
-      string16 url_string;
+      base::string16 url_string;
       if (stat_url.pwcsUrl) {
         url_string = stat_url.pwcsUrl;
         CoTaskMemFree(stat_url.pwcsUrl);
       }
-      string16 title_string;
+      base::string16 title_string;
       if (stat_url.pwcsTitle) {
         title_string = stat_url.pwcsTitle;
         CoTaskMemFree(stat_url.pwcsTitle);
       }
 
       GURL url(url_string);
       // Skips the URLs that are invalid or have other schemes.
       if (!url.is_valid() ||
           (std::find(kSchemes, kSchemes + total_schemes, url.scheme()) ==
            kSchemes + total_schemes))
@@ skipping 61 matching lines @@
 
   wchar_t* item_name;
   while (!cancelled() && SUCCEEDED(item->Next(1, &item_name, 0))) {
     DWORD length = 0;
     unsigned char* buffer = NULL;
     result = pstore->ReadItem(0, &AutocompleteGUID, &AutocompleteGUID,
                               item_name, &length, &buffer, NULL, 0);
     if (SUCCEEDED(result)) {
       AutoCompleteInfo ac;
       ac.key = item_name;
-      string16 data;
+      base::string16 data;
       data.insert(0, reinterpret_cast<wchar_t*>(buffer),
                   length / sizeof(wchar_t));
 
       // The key name is always ended with ":StringData".
       const wchar_t kDataSuffix[] = L":StringData";
       size_t i = ac.key.rfind(kDataSuffix);
-      if (i != string16::npos && ac.key.substr(i) == kDataSuffix) {
+      if (i != base::string16::npos && ac.key.substr(i) == kDataSuffix) {
         ac.key.erase(i);
-        ac.is_url = (ac.key.find(L"://") != string16::npos);
+        ac.is_url = (ac.key.find(L"://") != base::string16::npos);
         ac_list.push_back(ac);
         base::SplitString(data, L'\0', &ac_list[ac_list.size() - 1].data);
       }
       CoTaskMemFree(buffer);
     }
     CoTaskMemFree(item_name);
   }
   // Releases them before unload the dll.
   item.Release();
   pstore.Release();
@@ skipping 71 matching lines @@
 
     ++reg_iterator;
   }
 }
 
 void IEImporter::ImportSearchEngines() {
   // On IE, search engines are stored in the registry, under:
   // Software\Microsoft\Internet Explorer\SearchScopes
   // Each key represents a search engine. The URL value contains the URL and
   // the DisplayName the name.
-  typedef std::map<std::string, string16> SearchEnginesMap;
+  typedef std::map<std::string, base::string16> SearchEnginesMap;
   SearchEnginesMap search_engines_map;
   for (base::win::RegistryKeyIterator key_iter(HKEY_CURRENT_USER,
        kSearchScopePath); key_iter.Valid(); ++key_iter) {
-    string16 sub_key_name = kSearchScopePath;
+    base::string16 sub_key_name = kSearchScopePath;
     sub_key_name.append(L"\\").append(key_iter.Name());
     base::win::RegKey sub_key(HKEY_CURRENT_USER, sub_key_name.c_str(),
                               KEY_READ);
-    string16 wide_url;
+    base::string16 wide_url;
     if ((sub_key.ReadValue(L"URL", &wide_url) != ERROR_SUCCESS) ||
         wide_url.empty()) {
       VLOG(1) << "No URL for IE search engine at " << key_iter.Name();
       continue;
     }
     // For the name, we try the default value first (as Live Search uses a
     // non displayable name in DisplayName, and the readable name under the
     // default value).
-    string16 name;
+    base::string16 name;
     if ((sub_key.ReadValue(NULL, &name) != ERROR_SUCCESS) || name.empty()) {
       // Try the displayable name.
       if ((sub_key.ReadValue(L"DisplayName", &name) != ERROR_SUCCESS) ||
           name.empty()) {
         VLOG(1) << "No name for IE search engine at " << key_iter.Name();
         continue;
       }
     }
 
     std::string url(WideToUTF8(wide_url));
@@ skipping 18 matching lines @@
   bridge_->SetKeywords(url_keywords, true);
 }
 
 void IEImporter::ImportHomepage() {
   const wchar_t* kIEHomepage = L"Start Page";
   const wchar_t* kIEDefaultHomepage = L"Default_Page_URL";
 
   base::string16 key_path(importer::GetIESettingsKey());
 
   base::win::RegKey key(HKEY_CURRENT_USER, key_path.c_str(), KEY_READ);
-  string16 homepage_url;
+  base::string16 homepage_url;
   if (key.ReadValue(kIEHomepage, &homepage_url) != ERROR_SUCCESS ||
       homepage_url.empty())
     return;
 
   GURL homepage = GURL(homepage_url);
   if (!homepage.is_valid())
     return;
 
   // Check to see if this is the default website and skip import.
   base::win::RegKey keyDefault(HKEY_LOCAL_MACHINE, key_path.c_str(), KEY_READ);
-  string16 default_homepage_url;
+  base::string16 default_homepage_url;
   LONG result = keyDefault.ReadValue(kIEDefaultHomepage, &default_homepage_url);
   if (result == ERROR_SUCCESS && !default_homepage_url.empty()) {
     if (homepage.spec() == GURL(default_homepage_url).spec())
       return;
   }
   bridge_->AddHomePage(homepage);
 }
 
 bool IEImporter::GetFavoritesInfo(IEImporter::FavoritesInfo* info) {
   if (!source_path_.empty()) {
@@ skipping 116 matching lines @@
   static int version = -1;
   if (version < 0) {
     wchar_t buffer[128];
     DWORD buffer_length = sizeof(buffer);
     base::win::RegKey reg_key(HKEY_LOCAL_MACHINE, kIEVersionKey, KEY_READ);
     LONG result = reg_key.ReadValue(L"Version", buffer, &buffer_length, NULL);
     version = ((result == ERROR_SUCCESS)? _wtoi(buffer) : 0);
   }
   return version;
 }