Makes the default ctor of gfx::FontList copy the pre-calculated metrics.

ui/gfx/font_list.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/font_list.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 
 namespace {
 
 // Font description of the default font set.
 base::LazyInstance<std::string>::Leaky g_default_font_description =
     LAZY_INSTANCE_INITIALIZER;
 
+// The default instance of gfx::FontList, whose metrics are pre-calculated.
+// The default ctor of gfx::FontList copies the metrics so it won't need to
+// scan the whole font list to calculate the metrics.
+const gfx::FontList* g_default_font_list = NULL;
+
 // Parses font description into |font_names|, |font_style| and |font_size|.
 void ParseFontDescriptionString(const std::string& font_description_string,
                                 std::vector<std::string>* font_names,
                                 int* font_style,
                                 int* font_size) {
   base::SplitString(font_description_string, ',', font_names);
   DCHECK_GT(font_names->size(), 1U);
 
   // The last item is [STYLE_OPTIONS] SIZE.
   std::vector<std::string> styles_size;
@@ skipping 47 matching lines @@
 FontList::FontList()
     : common_height_(-1),
       common_baseline_(-1),
       font_style_(-1),
       font_size_(-1) {
   // SetDefaultFontDescription() must be called and the default font description
   // must be set earlier than any call of the default constructor.
   DCHECK(!(g_default_font_description == NULL))  // != is not overloaded.
       << "SetDefaultFontDescription has not been called.";
 
-  font_description_string_ = g_default_font_description.Get();
-  if (font_description_string_.empty())
-    fonts_.push_back(Font());
+  // Allocate the global instance of FontList for |g_default_font_list| without
+  // calling the default ctor.
+  static FontList default_font_list((Font()));
+
+  if (!g_default_font_list) {
+    default_font_list = g_default_font_description.Get().empty() ?
+        FontList(Font()) : FontList(g_default_font_description.Get());
+    // Pre-calculate the metrics if the underlying PlatformFont is supported.
+    // Note that not all the platforms support PlatformFont.

[msw, 2014/01/10 17:54:51]

What happens when the metics caching functions run in those scenarios? Is it
unsafe to run them and they should check this themselves, otherwise, why not
just run them here?

[Yuki, 2014/01/11 09:29:07]

If PlatformFont::CreateDefault() returns NULL, all metrics getter functions are
unsafe.  For example, Font::GetHeight(), Font::GetExpectedTextWidth(), etc. 
It's not only the metrics caching functions or FontList, but also Font.

Having said that, in that case, the metrics getter functions always crash
because of null pointer access and it's easy to detect.  So I don't think we
need to check the availability of PlatformFont every time.

+    if (default_font_list.GetPrimaryFont().platform_font()) {
+      default_font_list.CacheCommonFontHeightAndBaseline();
+      default_font_list.CacheFontStyleAndSize();
+    }
+    g_default_font_list = &default_font_list;
+  }
+
+  // Copy the default font list specification and its pre-calculated metrics.
+  *this = *g_default_font_list;
 }
 
 FontList::FontList(const std::string& font_description_string)
     : font_description_string_(font_description_string),
       common_height_(-1),
       common_baseline_(-1),
       font_style_(-1),
       font_size_(-1) {
   DCHECK(!font_description_string.empty());
   // DCHECK description string ends with "px" for size in pixel.
@@ skipping 42 matching lines @@
 }
 
 // static
 void FontList::SetDefaultFontDescription(const std::string& font_description) {
   // The description string must end with "px" for size in pixel, or must be
   // the empty string, which specifies to use a single default font.
   DCHECK(font_description.empty() ||
          EndsWith(font_description, "px", true));
 
   g_default_font_description.Get() = font_description;
+  g_default_font_list = NULL;
 }
 
 FontList FontList::DeriveFontList(int font_style) const {
   return DeriveFontListWithSizeDeltaAndStyle(0, font_style);
 }
 
 FontList FontList::DeriveFontListWithSize(int size) const {
   DCHECK_GT(size, 0);
   return DeriveFontListWithSizeDeltaAndStyle(size - GetFontSize(),
                                              GetFontStyle());
@@ skipping 135 matching lines @@
     font_style_ = fonts_[0].GetStyle();
     font_size_ = fonts_[0].GetFontSize();
   } else {
     std::vector<std::string> font_names;
     ParseFontDescriptionString(font_description_string_, &font_names,
                                &font_style_, &font_size_);
   }
 }
 
 }  // namespace gfx