Cache a screen compatible DC to avoid re-creating it excessively.

ui/gfx/render_text_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 "ui/gfx/render_text_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
-#include "base/win/scoped_hdc.h"
+#include "ui/gfx/screen_compatible_dc_win.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/platform_font.h"
 
 namespace {
 
 // The maximum supported number of Uniscribe runs; a SCRIPT_ITEM is 8 bytes.
 // TODO(msw): Review memory use/failure? Max string length? Alternate approach?
 const int kGuessItems = 100;
 const int kMaxItems = 10000;
@@ skipping 563 matching lines @@
       script_item++;
     if (script_item_end >= style_range_end)
       style++;
     run->range.set_end(run_break);
     runs_.push_back(run);
   }
 }
 
 void RenderTextWin::LayoutVisualText() {
   HRESULT hr = E_FAIL;
-  base::win::ScopedCreateDC hdc(CreateCompatibleDC(NULL));
+  ScopedTemporaryScreenCompatibleDC hdc;
   std::vector<internal::TextRun*>::const_iterator run_iter;
   for (run_iter = runs_.begin(); run_iter < runs_.end(); ++run_iter) {
     internal::TextRun* run = *run_iter;
     size_t run_length = run->range.length();
     const wchar_t* run_text = &(text()[run->range.start()]);
     bool tried_fallback = false;
 
     // Select the font desired for glyph generation.
-    SelectObject(hdc, run->font.GetNativeFont());
+    SelectObject(hdc.get(), run->font.GetNativeFont());
 
     run->logical_clusters.reset(new WORD[run_length]);
     run->glyph_count = 0;
     // Max glyph guess: http://msdn.microsoft.com/en-us/library/dd368564.aspx
     size_t max_glyphs = static_cast<size_t>(1.5 * run_length + 16);
     while (max_glyphs < kMaxGlyphs) {
       run->glyphs.reset(new WORD[max_glyphs]);
       run->visible_attributes.reset(new SCRIPT_VISATTR[max_glyphs]);
-      hr = ScriptShape(hdc,
+      hr = ScriptShape(hdc.get(),
                        &run->script_cache,
                        run_text,
                        run_length,
                        max_glyphs,
                        &(run->script_analysis),
                        run->glyphs.get(),
                        run->logical_clusters.get(),
                        run->visible_attributes.get(),
                        &(run->glyph_count));
       if (hr == E_OUTOFMEMORY) {
@@ skipping 10 matching lines @@
           // not found that can display the text. This is expected behavior
           // under Windows XP without additional language packs installed and
           // may also happen on newer versions when trying to display text in
           // an obscure script that the system doesn't have the right font for.
           hr = 0;
           break;
         }
 
         // The run's font doesn't contain the required glyphs, use an alternate.
         // TODO(msw): support RenderText's font_list().
-        if (ChooseFallbackFont(hdc, run->font, run_text, run_length,
+        if (ChooseFallbackFont(hdc.get(), run->font, run_text, run_length,
                                &run->font)) {
           ScriptFreeCache(&run->script_cache);
-          SelectObject(hdc, run->font.GetNativeFont());
+          SelectObject(hdc.get(), run->font.GetNativeFont());
         }
 
         tried_fallback = true;
       } else {
         break;
       }
     }
     DCHECK(SUCCEEDED(hr));
 
     if (run->glyph_count > 0) {
       run->advance_widths.reset(new int[run->glyph_count]);
       run->offsets.reset(new GOFFSET[run->glyph_count]);
-      hr = ScriptPlace(hdc,
+      hr = ScriptPlace(hdc.get(),
                        &run->script_cache,
                        run->glyphs.get(),
                        run->glyph_count,
                        run->visible_attributes.get(),
                        &(run->script_analysis),
                        run->advance_widths.get(),
                        run->offsets.get(),
                        &(run->abc_widths));
       DCHECK(SUCCEEDED(hr));
     }
@@ skipping 60 matching lines @@
     internal::TextRun* run) {
   size_t caret = IndexOfAdjacentGrapheme(run->range.end(), CURSOR_BACKWARD);
   return SelectionModel(caret, caret, SelectionModel::LEADING);
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx