Convert string16 to base::string16 in content.

content/common/font_cache_dispatcher_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 "content/common/font_cache_dispatcher_win.h"
 
 #include <map>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "content/common/child_process_messages.h"
 
 namespace content {
 namespace {
-typedef std::vector<string16> FontNameVector;
+typedef std::vector<base::string16> FontNameVector;
 typedef std::map<FontCacheDispatcher*, FontNameVector> DispatcherToFontNames;
 
 class FontCache {
  public:
   static FontCache* GetInstance() {
     return Singleton<FontCache>::get();
   }
 
   void PreCacheFont(const LOGFONT& font, FontCacheDispatcher* dispatcher) {
-    typedef std::map<string16, FontCache::CacheElement> FontNameToElement;
+    typedef std::map<base::string16, FontCache::CacheElement> FontNameToElement;
 
     base::AutoLock lock(mutex_);
 
     // Fetch the font into memory.
     // No matter the font is cached or not, we load it to avoid GDI swapping out
     // that font file.
     HDC hdc = GetDC(NULL);
     HFONT font_handle = CreateFontIndirect(&font);
     DCHECK(NULL != font_handle);
 
     HGDIOBJ old_font = SelectObject(hdc, font_handle);
     DCHECK(NULL != old_font);
 
     TEXTMETRIC tm;
     BOOL ret = GetTextMetrics(hdc, &tm);
     DCHECK(ret);
 
-    string16 font_name = font.lfFaceName;
+    base::string16 font_name = font.lfFaceName;
     int ref_count_inc = 1;
     FontNameVector::iterator it =
         std::find(dispatcher_font_map_[dispatcher].begin(),
                   dispatcher_font_map_[dispatcher].end(),
                   font_name);
     if (it == dispatcher_font_map_[dispatcher].end()) {
       // Requested font is new to cache.
       dispatcher_font_map_[dispatcher].push_back(font_name);
     } else {
       ref_count_inc = 0;
     }
 
     if (cache_[font_name].ref_count_ == 0) {  // Requested font is new to cache.
       cache_[font_name].ref_count_ = 1;
     } else {  // Requested font is already in cache, release old handles.
       SelectObject(cache_[font_name].dc_, cache_[font_name].old_font_);
       DeleteObject(cache_[font_name].font_);
       ReleaseDC(NULL, cache_[font_name].dc_);
     }
     cache_[font_name].font_ = font_handle;
     cache_[font_name].dc_ = hdc;
     cache_[font_name].old_font_ = old_font;
     cache_[font_name].ref_count_ += ref_count_inc;
   }
 
   void ReleaseCachedFonts(FontCacheDispatcher* dispatcher) {
-    typedef std::map<string16, FontCache::CacheElement> FontNameToElement;
+    typedef std::map<base::string16, FontCache::CacheElement> FontNameToElement;
 
     base::AutoLock lock(mutex_);
 
     DispatcherToFontNames::iterator it;
     it = dispatcher_font_map_.find(dispatcher);
     if (it == dispatcher_font_map_.end()) {
       return;
     }
 
     for (FontNameVector::iterator i = it->second.begin(), e = it->second.end();
@@ skipping 36 matching lines @@
     HFONT font_;
     HGDIOBJ old_font_;
     HDC dc_;
     int ref_count_;
   };
   friend struct DefaultSingletonTraits<FontCache>;
 
   FontCache() {
   }
 
-  std::map<string16, CacheElement> cache_;
+  std::map<base::string16, CacheElement> cache_;
   DispatcherToFontNames dispatcher_font_map_;
   base::Lock mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(FontCache);
 };
 
 }
 
 FontCacheDispatcher::FontCacheDispatcher()
     : channel_(NULL) {
@@ skipping 46 matching lines @@
   FontCache::GetInstance()->PreCacheFont(font, this);
 }
 
 void FontCacheDispatcher::OnReleaseCachedFonts() {
   // Release cached fonts that requested from a pid by decrementing the ref
   // count.  When ref count is zero, the handles are released.
   FontCache::GetInstance()->ReleaseCachedFonts(this);
 }
 
 }  // namespace content