Remove all uses of skia::RefPtr and stale includes

content/child/font_warmup_win.cc

 // Copyright 2014 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/child/font_warmup_win.h"
 
 #include <dwrite.h>
 #include <stdint.h>
 #include <map>
 
 #include "base/debug/alias.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_byteorder.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/iat_patch_function.h"
 #include "base/win/windows_version.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "skia/ext/fontmgr_default_win.h"
-#include "skia/ext/refptr.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/ports/SkFontMgr.h"
 #include "third_party/skia/include/ports/SkTypeface_win.h"
 
 namespace content {
 
 namespace {
 
 // The Skia font manager, used for the life of the process (leaked at the end).
 SkFontMgr* g_warmup_fontmgr = nullptr;
 
@@ skipping 58 matching lines @@
   return STATUS_ACCESS_DENIED;
 }
 
 // Class to fake out a DC or a Font object. Maintains a reference to a
 // SkTypeFace to emulate the simple operation of a DC and Font.
 class FakeGdiObject : public base::RefCountedThreadSafe<FakeGdiObject> {
  public:
   FakeGdiObject(uint32_t magic, void* handle)
       : handle_(handle), magic_(magic) {}
 
-  void set_typeface(const skia::RefPtr<SkTypeface>& typeface) {
-    typeface_ = typeface;
+  void set_typeface(sk_sp<SkTypeface> typeface) {
+    typeface_ = std::move(typeface);
   }
 
-  skia::RefPtr<SkTypeface> typeface() { return typeface_; }
+  sk_sp<SkTypeface> typeface() { return typeface_; }
   void* handle() { return handle_; }
   uint32_t magic() { return magic_; }
 
  private:
   friend class base::RefCountedThreadSafe<FakeGdiObject>;
   ~FakeGdiObject() {}
 
   void* handle_;
   uint32_t magic_;
-  skia::RefPtr<SkTypeface> typeface_;
+  sk_sp<SkTypeface> typeface_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGdiObject);
 };
 
 // This class acts as a factory for creating new fake GDI objects. It also maps
 // the new instances of the FakeGdiObject class to an incrementing handle value
 // which is passed to the caller of the emulated GDI function for later
 // reference.  We can't be sure that this won't be used in a multi-threaded
 // environment so we need to ensure a lock is taken before accessing the map of
 // issued objects.
@@ skipping 55 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeGdiObjectFactory);
 };
 
 base::LazyInstance<FakeGdiObjectFactory>::Leaky g_fake_gdi_object_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // Magic values for the fake GDI objects.
 const uint32_t kFakeDCMagic = 'fkdc';
 const uint32_t kFakeFontMagic = 'fkft';
 
-skia::RefPtr<SkTypeface> GetTypefaceFromLOGFONT(const LOGFONTW* log_font) {
+sk_sp<SkTypeface> GetTypefaceFromLOGFONT(const LOGFONTW* log_font) {
   CHECK(g_warmup_fontmgr);
   int weight = log_font->lfWeight;
   if (weight == FW_DONTCARE)
     weight = SkFontStyle::kNormal_Weight;
 
   SkFontStyle style(weight, log_font->lfWidth,
                     log_font->lfItalic ? SkFontStyle::kItalic_Slant
                                        : SkFontStyle::kUpright_Slant);
 
   std::string family_name = base::WideToUTF8(log_font->lfFaceName);
   ppapi::ProxyAutoLock lock;  // Needed for DirectWrite font proxy.
-  return skia::AdoptRef(
+  return sk_sp<SkTypeface>(
       g_warmup_fontmgr->matchFamilyStyle(family_name.c_str(), style));
 }
 
 HDC WINAPI CreateCompatibleDCPatch(HDC dc_handle) {
   scoped_refptr<FakeGdiObject> ret =
       g_fake_gdi_object_factory.Get().Create(kFakeDCMagic);
   return static_cast<HDC>(ret->handle());
 }
 
 HFONT WINAPI CreateFontIndirectWPatch(const LOGFONTW* log_font) {
   if (!log_font)
     return nullptr;
 
-  skia::RefPtr<SkTypeface> typeface = GetTypefaceFromLOGFONT(log_font);
+  sk_sp<SkTypeface> typeface = GetTypefaceFromLOGFONT(log_font);
   if (!typeface)
     return nullptr;
 
   scoped_refptr<FakeGdiObject> ret =
       g_fake_gdi_object_factory.Get().Create(kFakeFontMagic);
-  ret->set_typeface(typeface);
+  ret->set_typeface(std::move(typeface));
 
   return static_cast<HFONT>(ret->handle());
 }
 
 BOOL WINAPI DeleteDCPatch(HDC dc_handle) {
   return g_fake_gdi_object_factory.Get().DeleteObject(dc_handle, kFakeDCMagic);
 }
 
 BOOL WINAPI DeleteObjectPatch(HGDIOBJ object_handle) {
   return g_fake_gdi_object_factory.Get().DeleteObject(object_handle,
                                                       kFakeFontMagic);
 }
 
 int WINAPI EnumFontFamiliesExWPatch(HDC dc_handle,
                                     LPLOGFONTW log_font,
                                     FONTENUMPROCW enum_callback,
                                     LPARAM callback_param,
                                     DWORD flags) {
   scoped_refptr<FakeGdiObject> dc_obj =
       g_fake_gdi_object_factory.Get().Validate(dc_handle, kFakeDCMagic);
   if (!dc_obj)
     return 1;
 
   if (!log_font || !enum_callback)
     return 1;
 
-  skia::RefPtr<SkTypeface> typeface = GetTypefaceFromLOGFONT(log_font);
+  sk_sp<SkTypeface> typeface = GetTypefaceFromLOGFONT(log_font);
   if (!typeface)
     return 1;
 
   ENUMLOGFONTEXDVW enum_log_font = {};
   enum_log_font.elfEnumLogfontEx.elfLogFont = *log_font;
   // TODO: Fill in the rest of the text metric structure. Not yet needed for
   // Flash support but might be in the future.
   NEWTEXTMETRICEXW text_metric = {};
   text_metric.ntmTm.ntmFlags = NTM_PS_OPENTYPE;
 
   return enum_callback(&enum_log_font.elfEnumLogfontEx.elfLogFont,
                        reinterpret_cast<TEXTMETRIC*>(&text_metric),
                        TRUETYPE_FONTTYPE, callback_param);
 }
 
 DWORD WINAPI GetFontDataPatch(HDC dc_handle,
                               DWORD table_tag,
                               DWORD table_offset,
                               LPVOID buffer,
                               DWORD buffer_length) {
   scoped_refptr<FakeGdiObject> dc_obj =
       g_fake_gdi_object_factory.Get().Validate(dc_handle, kFakeDCMagic);
   if (!dc_obj)
     return GDI_ERROR;
 
-  skia::RefPtr<SkTypeface> typeface = dc_obj->typeface();
+  sk_sp<SkTypeface> typeface = dc_obj->typeface();
   if (!typeface)
     return GDI_ERROR;
 
   // |getTableData| handles |buffer| being nullptr. However if it is nullptr
   // then set the size to INT32_MAX otherwise |getTableData| will return the
   // minimum value between the table entry size and the size passed in. The
   // common Windows idiom is to pass 0 as |buffer_length| when passing nullptr,
   // which would in this case result in |getTableData| returning 0 which isn't
   // the correct answer for emulating GDI. |table_tag| must also have its
   // byte order swapped to counter the swap which occurs in the called method.
@@ skipping 13 matching lines @@
   if (!dc_obj)
     return nullptr;
 
   scoped_refptr<FakeGdiObject> font_obj =
       g_fake_gdi_object_factory.Get().Validate(object_handle, kFakeFontMagic);
   if (!font_obj)
     return nullptr;
 
   // Construct a new fake font object to handle the old font if there's one.
   scoped_refptr<FakeGdiObject> new_font_obj;
-  skia::RefPtr<SkTypeface> old_typeface = dc_obj->typeface();
+  sk_sp<SkTypeface> old_typeface = dc_obj->typeface();
   if (old_typeface) {
     new_font_obj = g_fake_gdi_object_factory.Get().Create(kFakeFontMagic);
-    new_font_obj->set_typeface(old_typeface);
+    new_font_obj->set_typeface(std::move(old_typeface));
   }
   dc_obj->set_typeface(font_obj->typeface());
 
   if (new_font_obj)
     return static_cast<HGDIOBJ>(new_font_obj->handle());
   return nullptr;
 }
 
 void DoSingleGdiPatch(base::win::IATPatchFunction& patch,
                       const base::FilePath& path,
@@ skipping 97 matching lines @@
 
 void ResetEmulatedGdiHandlesForTesting() {
   g_fake_gdi_object_factory.Get().ResetObjectHandles();
 }
 
 void SetPreSandboxWarmupFontMgrForTesting(SkFontMgr* fontmgr) {
   g_warmup_fontmgr = fontmgr;
 }
 
 }  // namespace content