Here is the pattern I observed in gles2_cmd_decoder.cc and elsewhere:

// 1) Allocate (and zero) a temp buffer
    std::unique_ptr<char[]> zero(new char[pixels_size]);
    memset(zero.get(), 0, pixels_size);

// 2) Use the zero buffer to populate a texture
    glTexImage2D(target, level, TextureManager::AdjustTexInternalFormat(
                                    feature_info_.get(), internal_format),
                 width, height, border, format, type, zero.get());

// 3) Do a bunch of other stuff that doesn't need the |zero| buffer.
    if (!src.IsEmpty()) {
      GLint destX = src.x() - x;
      GLint destY = src.y() - y;
      if (requires_luma_blit) {
        copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
            this, texture->service_id(), texture->target(), target, format,
            type, level, destX, destY, 0,
            src.x(), src.y(), src.width(), src.height(),
            GetBoundReadFramebufferServiceId(),
            GetBoundReadFramebufferInternalFormat());
      } else {
        glCopyTexSubImage2D(target, level, destX, destY,
                            src.x(), src.y(), src.width(), src.height());
      }
    }

The temporary buffer remains on the heap for longer than necessary so other allocations could be made on top of it on the current thread or on any different thread. This increases memory pressure more than necessary.
Consider freeing the buffer immediately after its last usage.
It might be even cleaner to use a some sort of a "zero memory" class that could be passed directly to glTexImage2D and destroyed at the end of the call e.g.

    glTexImage2D(..., ZeroBuffer(pixels_size).data());

Look for std::unique_ptr<char[]> or std::unique_ptr<int8_t[]> for more instances of this pattern.