Remove obsolete for_web_contents parameter in FontRenderParamsQuery.

ui/gfx/platform_font_linux.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/platform_font_linux.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/lazy_instance.h"
@@ skipping 61 matching lines @@
   if (!g_default_font.Get()) {
     std::string family = kFallbackFontFamilyName;
     int size_pixels = 12;
     int style = Font::NORMAL;
     FontRenderParams params;
 
 #if defined(OS_CHROMEOS)
     // On Chrome OS, a FontList font description string is stored as a
     // translatable resource and passed in via SetDefaultFontDescription().
     if (default_font_description_) {
-      FontRenderParamsQuery query(false /* for_web_contents */);
+      FontRenderParamsQuery query;
       CHECK(FontList::ParseDescription(*default_font_description_,
                                        &query.families, &query.style,
                                        &query.pixel_size))
           << "Failed to parse font description " << *default_font_description_;
       params = gfx::GetFontRenderParams(query, &family);
       size_pixels = query.pixel_size;
       style = query.style;
     }
 #else
     // On Linux, LinuxFontDelegate is used to query the native toolkit (e.g.
     // GTK+) for the default UI font.
     const LinuxFontDelegate* delegate = LinuxFontDelegate::instance();
     if (delegate) {
       delegate->GetDefaultFontDescription(
           &family, &size_pixels, &style, &params);
     }
 #endif
 
     g_default_font.Get() = new PlatformFontLinux(
         CreateSkTypeface(style, &family), family, size_pixels, style, params);
   }
 
   InitFromPlatformFont(g_default_font.Get().get());
 }
 
 PlatformFontLinux::PlatformFontLinux(const std::string& font_name,
                                      int font_size_pixels) {
-  FontRenderParamsQuery query(false);
+  FontRenderParamsQuery query;
   query.families.push_back(font_name);
   query.pixel_size = font_size_pixels;
   query.style = Font::NORMAL;
   InitFromDetails(skia::RefPtr<SkTypeface>(), font_name, font_size_pixels,
                   query.style, gfx::GetFontRenderParams(query, NULL));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontLinux, PlatformFont implementation:
 
@@ skipping 15 matching lines @@
 
 Font PlatformFontLinux::DeriveFont(int size_delta, int style) const {
   const int new_size = font_size_pixels_ + size_delta;
   DCHECK_GT(new_size, 0);
 
   // If the style changed, we may need to load a new face.
   std::string new_family = font_family_;
   skia::RefPtr<SkTypeface> typeface =
       (style == style_) ? typeface_ : CreateSkTypeface(style, &new_family);
 
-  FontRenderParamsQuery query(false);
+  FontRenderParamsQuery query;
   query.families.push_back(new_family);
   query.pixel_size = new_size;
   query.style = style;
 
   return Font(new PlatformFontLinux(typeface, new_family, new_size, style,
                                     gfx::GetFontRenderParams(query, NULL)));
 }
 
 int PlatformFontLinux::GetHeight() const {
   return height_pixels_;
@@ skipping 26 matching lines @@
 }
 
 int PlatformFontLinux::GetFontSize() const {
   return font_size_pixels_;
 }
 
 const FontRenderParams& PlatformFontLinux::GetFontRenderParams() {
 #if defined(OS_CHROMEOS)
   float current_scale_factor = GetFontRenderParamsDeviceScaleFactor();
   if (current_scale_factor != device_scale_factor_) {
-    FontRenderParamsQuery query(false);
+    FontRenderParamsQuery query;
     query.families.push_back(font_family_);
     query.pixel_size = font_size_pixels_;
     query.style = style_;
     query.device_scale_factor = current_scale_factor;
     font_render_params_ = gfx::GetFontRenderParams(query, nullptr);
     device_scale_factor_ = current_scale_factor;
   }
 #endif
   return font_render_params_;
 }
@@ skipping 68 matching lines @@
   return new PlatformFontLinux;
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontLinux(font_name, font_size);
 }
 
 }  // namespace gfx