Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

ui/gfx/platform_font_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/platform_font_win.h"
 
 #include <windows.h>
 #include <dwrite.h>
 #include <limits.h>
 #include <math.h>
@@ skipping 63 matching lines @@
 // Uses the GDI interop functionality exposed by DirectWrite to find a
 // matching DirectWrite font for the LOGFONT passed in. If we fail to
 // find a direct match then we try the DirectWrite font substitution
 // route to find a match.
 // The contents of the LOGFONT pointer |font_info| may be modified on
 // return.
 HRESULT FindDirectWriteFontForLOGFONT(IDWriteFactory* factory,
                                       LOGFONT* font_info,
                                       IDWriteFont** dwrite_font) {
   base::win::ScopedComPtr<IDWriteGdiInterop> gdi_interop;
-  HRESULT hr = factory->GetGdiInterop(gdi_interop.Receive());
+  HRESULT hr = factory->GetGdiInterop(gdi_interop.GetAddressOf());
   if (FAILED(hr)) {
     CHECK(false);
     return hr;
   }
 
   hr = gdi_interop->CreateFontFromLOGFONT(font_info, dwrite_font);
   if (SUCCEEDED(hr))
     return hr;
 
   base::win::ScopedComPtr<IDWriteFontCollection> font_collection;
-  hr = factory->GetSystemFontCollection(font_collection.Receive());
+  hr = factory->GetSystemFontCollection(font_collection.GetAddressOf());
   if (FAILED(hr)) {
     CHECK(false);
     return hr;
   }
 
   // We try to find a matching font by triggering DirectWrite to substitute the
   // font passed in with a matching font (FontSubstitutes registry key)
   // If this succeeds we return the matched font.
   base::win::ScopedGDIObject<HFONT> font(::CreateFontIndirect(font_info));
   base::win::ScopedGetDC screen_dc(NULL);
   base::win::ScopedSelectObject scoped_font(screen_dc, font.get());
 
   base::win::ScopedComPtr<IDWriteFontFace> font_face;
-  hr = gdi_interop->CreateFontFaceFromHdc(screen_dc, font_face.Receive());
+  hr = gdi_interop->CreateFontFaceFromHdc(screen_dc, font_face.GetAddressOf());
   if (FAILED(hr))
     return hr;
 
   LOGFONT converted_font = {0};
   hr = gdi_interop->ConvertFontFaceToLOGFONT(font_face.Get(), &converted_font);
   if (SUCCEEDED(hr)) {
     hr = font_collection->GetFontFromFontFace(font_face.Get(), dwrite_font);
     if (SUCCEEDED(hr)) {
       wcscpy_s(font_info->lfFaceName, arraysize(font_info->lfFaceName),
                converted_font.lfFaceName);
@@ skipping 15 matching lines @@
   // First try the GDI compat route to get a matching DirectWrite font.
   // If that succeeds then we are good. If that fails then try and find a
   // match from the DirectWrite font collection.
   HRESULT hr = FindDirectWriteFontForLOGFONT(factory, font_info, dwrite_font);
   if (SUCCEEDED(hr))
     return hr;
 
   // Get a matching font from the system font collection exposed by
   // DirectWrite.
   base::win::ScopedComPtr<IDWriteFontCollection> font_collection;
-  hr = factory->GetSystemFontCollection(font_collection.Receive());
+  hr = factory->GetSystemFontCollection(font_collection.GetAddressOf());
   if (FAILED(hr)) {
     CHECK(false);
     return hr;
   }
 
   // Steps as below:-
   // This mirrors skia.
   // 1. Attempt to find a DirectWrite font family based on the face name in the
   //    font. That may not work at all times, as the face name could be random
   //    GDI has its own font system where in it creates a font matching the
@@ skipping 33 matching lines @@
         return hr;
 
       // Best effort to find a matching font from the system font collection.
       hr = font_collection->FindFamilyName(metrics.lfMessageFont.lfFaceName,
                                            &index,
                                            &exists);
     }
   }
 
   if (index != UINT_MAX && exists) {
-    hr = font_collection->GetFontFamily(index, font_family.Receive());
+    hr = font_collection->GetFontFamily(index, font_family.GetAddressOf());
   } else {
     // If we fail to find a matching font, then fallback to the first font in
     // the list. This is what skia does as well.
-    hr = font_collection->GetFontFamily(0, font_family.Receive());
+    hr = font_collection->GetFontFamily(0, font_family.GetAddressOf());
   }
 
   if (FAILED(hr)) {
     CHECK(false);
     return hr;
   }
 
   DWRITE_FONT_WEIGHT weight =
       static_cast<DWRITE_FONT_WEIGHT>(font_info->lfWeight);
   DWRITE_FONT_STRETCH stretch = DWRITE_FONT_STRETCH_NORMAL;
   DWRITE_FONT_STYLE style =
       (italic) ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
 
   // The IDWriteFontFamily::GetFirstMatchingFont call fails on certain machines
   // for fonts like MS UI Gothic, Segoe UI, etc. It is not clear why these
   // fonts could be accessible to GDI and not to DirectWrite.
   // The code below adds some debug fields to help track down these failures.
   // 1. We get the matching font list for the font attributes passed in.
   // 2. We get the font count in the family with a debug alias variable.
   // 3. If GetFirstMatchingFont fails then we CHECK as before.
   // Next step would be to remove the CHECKs in this function and fallback to
   // GDI.
   // http://crbug.com/434425
   // TODO(ananta)
   // Remove the GetMatchingFonts and related code here once we get to a stable
   // state in canary.
   base::win::ScopedComPtr<IDWriteFontList> matching_font_list;
   hr = font_family->GetMatchingFonts(weight, stretch, style,
-                                     matching_font_list.Receive());
+                                     matching_font_list.GetAddressOf());
   uint32_t matching_font_count = 0;
   if (SUCCEEDED(hr))
     matching_font_count = matching_font_list->GetFontCount();
 
   hr = font_family->GetFirstMatchingFont(weight, stretch, style, dwrite_font);
   if (FAILED(hr)) {
     base::debug::Alias(&matching_font_count);
     CHECK(false);
   }
 
@@ skipping 17 matching lines @@
 PlatformFontWin::GetMinimumFontSizeCallback
     PlatformFontWin::get_minimum_font_size_callback = NULL;
 
 IDWriteFactory* PlatformFontWin::direct_write_factory_ = nullptr;
 
 // TODO(ananta)
 // Remove the CHECKs in this function once this stabilizes on the field.
 HRESULT GetFamilyNameFromDirectWriteFont(IDWriteFont* dwrite_font,
                                          base::string16* family_name) {
   base::win::ScopedComPtr<IDWriteFontFamily> font_family;
-  HRESULT hr = dwrite_font->GetFontFamily(font_family.Receive());
+  HRESULT hr = dwrite_font->GetFontFamily(font_family.GetAddressOf());
   if (FAILED(hr))
     CHECK(false);
 
   base::win::ScopedComPtr<IDWriteLocalizedStrings> family_names;
-  hr = font_family->GetFamilyNames(family_names.Receive());
+  hr = font_family->GetFamilyNames(family_names.GetAddressOf());
   if (FAILED(hr))
     CHECK(false);
 
   // TODO(ananta)
   // Add support for retrieving the family for the current locale.
   wchar_t family_name_for_locale[MAX_PATH] = {0};
   hr = family_names->GetString(0, family_name_for_locale,
                                arraysize(family_name_for_locale));
   if (FAILED(hr))
     CHECK(false);
@@ skipping 232 matching lines @@
 
   // Skia does not return all values we need for font metrics. For e.g.
   // the cap height which indicates the height of capital letters is not
   // returned even though it is returned by DirectWrite.
   // TODO(ananta)
   // Fix SkScalerContext_win_dw.cpp to return all metrics we need from
   // DirectWrite and remove the code here which retrieves metrics from
   // DirectWrite to calculate the cap height.
   base::win::ScopedComPtr<IDWriteFont> dwrite_font;
   HRESULT hr = GetMatchingDirectWriteFont(
-      &font_info, italic, direct_write_factory_, dwrite_font.Receive());
+      &font_info, italic, direct_write_factory_, dwrite_font.GetAddressOf());
   if (FAILED(hr)) {
     CHECK(false);
     return nullptr;
   }
 
   DWRITE_FONT_METRICS dwrite_font_metrics = {0};
   dwrite_font->GetMetrics(&dwrite_font_metrics);
 
   SkFontStyle skia_font_style(font_info.lfWeight, SkFontStyle::kNormal_Width,
                               font_info.lfItalic ? SkFontStyle::kItalic_Slant
@@ skipping 140 matching lines @@
   return new PlatformFontWin(native_font);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontWin(font_name, font_size);
 }
 
 }  // namespace gfx