Revert of Don't allow nullptr in texels array params (unless using a transfer buffer).

src/gpu/GrGpu.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpu.h"
 
@@ skipping 80 matching lines @@
 
 /**
  * Prior to creating a texture, make sure the type of texture being created is
  * supported by calling check_texture_creation_params.
  *
  * @param caps The capabilities of the GL device.
  * @param desc The descriptor of the texture to create.
  * @param isRT Indicates if the texture can be a render target.
  */
 static bool check_texture_creation_params(const GrCaps& caps, const GrSurfaceDesc& desc,
-                                          bool* isRT, const SkTArray<GrMipLevel>& texels) {
+                                          bool* isRT) {
     if (!caps.isConfigTexturable(desc.fConfig)) {
         return false;
     }
 
     *isRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
     if (*isRT && !caps.isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
         return false;
     }
 
     // We currently do not support multisampled textures
     if (!*isRT && desc.fSampleCnt > 0) {
         return false;
     }
 
     if (*isRT) {
         int maxRTSize = caps.maxRenderTargetSize();
         if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) {
             return false;
         }
     } else {
         int maxSize = caps.maxTextureSize();
         if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
             return false;
         }
     }
-
-    for (int i = 0; i < texels.count(); ++i) {
-        if (!texels[i].fPixels) {
-            return false;
-        }
-    }
     return true;
 }
 
 GrTexture* GrGpu::createTexture(const GrSurfaceDesc& origDesc, SkBudgeted budgeted,
                                 const SkTArray<GrMipLevel>& texels) {
     GrSurfaceDesc desc = origDesc;
 
     const GrCaps* caps = this->caps();
     bool isRT = false;
-    bool textureCreationParamsValid = check_texture_creation_params(*caps, desc, &isRT, texels);
+    bool textureCreationParamsValid = check_texture_creation_params(*caps, desc, &isRT);
     if (!textureCreationParamsValid) {
         return nullptr;
     }
 
     desc.fSampleCnt = SkTMin(desc.fSampleCnt, caps->maxSampleCount());
     // Attempt to catch un- or wrongly intialized sample counts;
     SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
 
     desc.fOrigin = resolve_origin(desc.fOrigin, isRT);
 
@@ skipping 25 matching lines @@
         fStats.incTextureCreates();
         if (!texels.empty()) {
             if (texels[0].fPixels) {
                 fStats.incTextureUploads();
             }
         }
     }
     return tex;
 }
 
+GrTexture* GrGpu::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
+                                const void* srcData, size_t rowBytes) {
+    GrMipLevel level;
+    level.fPixels = srcData;
+    level.fRowBytes = rowBytes;
+    SkSTArray<1, GrMipLevel> levels;
+    levels.push_back(level);
+
+    return this->createTexture(desc, budgeted, levels);
+}
+
 GrTexture* GrGpu::wrapBackendTexture(const GrBackendTextureDesc& desc, GrWrapOwnership ownership) {
     this->handleDirtyContext();
     if (!this->caps()->isConfigTexturable(desc.fConfig)) {
         return nullptr;
     }
     if ((desc.fFlags & kRenderTarget_GrBackendTextureFlag) &&
         !this->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
         return nullptr;
     }
     int maxSize = this->caps()->maxTextureSize();
@@ skipping 181 matching lines @@
                               config, buffer,
                               rowBytes);
 }
 
 bool GrGpu::writePixels(GrSurface* surface,
                         int left, int top, int width, int height,
                         GrPixelConfig config, const SkTArray<GrMipLevel>& texels) {
     if (!surface) {
         return false;
     }
+    bool validMipDataFound = false;
     for (int currentMipLevel = 0; currentMipLevel < texels.count(); currentMipLevel++) {
-        if (!texels[currentMipLevel].fPixels ) {
-            return false;
+        if (texels[currentMipLevel].fPixels != nullptr) {
+            validMipDataFound = true;
+            break;
         }
     }
+    if (!validMipDataFound) {
+        return false;
+    }
 
     this->handleDirtyContext();
     if (this->onWritePixels(surface, left, top, width, height, config, texels)) {
         fStats.incTextureUploads();
         return true;
     }
     return false;
 }
 
 bool GrGpu::writePixels(GrSurface* surface,
@@ skipping 39 matching lines @@
     }
 
     GrVertices::Iterator iter;
     const GrNonInstancedVertices* verts = iter.init(vertices);
     do {
         this->onDraw(args, *verts);
         fStats.incNumDraws();
     } while ((verts = iter.next()));
 }