Rename GrContext's newDrawContext & drawContext to makeDrawContext

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 86 matching lines @@
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
         return nullptr;
     }
 
     const int width = rt->width();
     const int height = rt->height();
 
     GrContext* context = rt->getContext();
 
-    sk_sp<GrDrawContext> drawContext(context->drawContext(std::move(rt), std::move(colorSpace),
-                                                          props));
+    sk_sp<GrDrawContext> drawContext(context->makeDrawContext(std::move(rt), std::move(colorSpace),
+                                                              props));
     return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
 }
 
 sk_sp<SkBaseDevice> SkGpuDevice::Make(sk_sp<GrDrawContext> drawContext,
                                       int width, int height,
                                       InitContents init) {
     if (!drawContext || drawContext->wasAbandoned()) {
         return nullptr;
     }
     unsigned flags;
@@ skipping 61 matching lines @@
     }
 
     GrPixelConfig origConfig = SkImageInfo2GrPixelConfig(ct, at, cs, *context->caps());
     if (!context->caps()->isConfigRenderable(origConfig, sampleCount > 0)) {
         // Fall back from whatever ct was to default of kRGBA or kBGRA which is aliased as kN32
         ct = kN32_SkColorType;
     }
 
     GrPixelConfig config = SkImageInfo2GrPixelConfig(ct, at, cs, *context->caps());
 
-    return context->newDrawContext(SkBackingFit::kExact,               // Why exact?
-                                   origInfo.width(), origInfo.height(),
-                                   config, sk_ref_sp(cs), sampleCount,
-                                   origin, surfaceProps, budgeted);
+    return context->makeDrawContext(SkBackingFit::kExact,               // Why exact?
+                                    origInfo.width(), origInfo.height(),
+                                    config, sk_ref_sp(cs), sampleCount,
+                                    origin, surfaceProps, budgeted);
 }
 
 sk_sp<SkSpecialImage> SkGpuDevice::filterTexture(const SkDraw& draw,
                                                  SkSpecialImage* srcImg,
                                                  int left, int top,
                                                  SkIPoint* offset,
                                                  const SkImageFilter* filter) {
     SkASSERT(srcImg->isTextureBacked());
     SkASSERT(filter);
 
@@ skipping 1534 matching lines @@
 SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
     ASSERT_SINGLE_OWNER
 
     SkSurfaceProps props(this->surfaceProps().flags(), cinfo.fPixelGeometry);
 
     // layers are never drawn in repeat modes, so we can request an approx
     // match and ignore any padding.
     SkBackingFit fit = kNever_TileUsage == cinfo.fTileUsage ? SkBackingFit::kApprox
                                                             : SkBackingFit::kExact;
 
-    sk_sp<GrDrawContext> dc(fContext->newDrawContext(fit,
-                                                     cinfo.fInfo.width(), cinfo.fInfo.height(),
-                                                     fDrawContext->config(),
-                                                     sk_ref_sp(fDrawContext->getColorSpace()),
-                                                     fDrawContext->desc().fSampleCnt,
-                                                     kDefault_GrSurfaceOrigin,
-                                                     &props));
+    sk_sp<GrDrawContext> dc(fContext->makeDrawContext(fit,
+                                                      cinfo.fInfo.width(), cinfo.fInfo.height(),
+                                                      fDrawContext->config(),
+                                                      sk_ref_sp(fDrawContext->getColorSpace()),
+                                                      fDrawContext->desc().fSampleCnt,
+                                                      kDefault_GrSurfaceOrigin,
+                                                      &props));
     if (!dc) {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "---- failed to create gpu device texture [%d %d]\n",
                                     cinfo.fInfo.width(), cinfo.fInfo.height());
         return nullptr;    
     }
 
     // Skia's convention is to only clear a device if it is non-opaque.
     InitContents init = cinfo.fInfo.isOpaque() ? kUninit_InitContents : kClear_InitContents;
 
@@ skipping 11 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif