Reduce unique_ptr scope to save memory

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 2619 matching lines @@
   if (!memory_tracker_.EnsureGPUMemoryAvailable(image_size)) {
     return false;
   }
 
   bool success = false;
   size_ = size;
   if (decoder_->should_use_native_gmb_for_backbuffer_) {
     DestroyNativeGpuMemoryBuffer(true);
     success = AllocateNativeGpuMemoryBuffer(size, format, zero);
   } else {
-    std::unique_ptr<char[]> zero_data;
-    if (zero) {
-      zero_data.reset(new char[image_size]);
-      memset(zero_data.get(), 0, image_size);
+    {
+      // Add extra scope to destroy zero_data and the object it owns right
+      // after its usage.
+      std::unique_ptr<char[]> zero_data;
+      if (zero) {
+        zero_data.reset(new char[image_size]);
+        memset(zero_data.get(), 0, image_size);
+      }
+
+      glTexImage2D(Target(),
+        0,  // mip level
+        format, size.width(), size.height(),
+        0,  // border
+        format, GL_UNSIGNED_BYTE, zero_data.get());
     }
 
-    glTexImage2D(Target(),
-                 0,  // mip level
-                 format, size.width(), size.height(),
-                 0,  // border
-                 format, GL_UNSIGNED_BYTE, zero_data.get());
     decoder_->texture_manager()->SetLevelInfo(
         texture_ref_.get(), Target(),
         0,  // level
         GL_RGBA, size.width(), size.height(),
         1,  // depth
         0,  // border
         GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(size));
     success = glGetError() == GL_NO_ERROR;
   }
 
@@ skipping 9590 matching lines @@
     tile_height = kMaxZeroSize / padded_row_size;
     if (!GLES2Util::ComputeImageDataSizes(
             width, tile_height, 1, format, type, state_.unpack_alignment, &size,
             NULL, NULL)) {
       return false;
     }
   } else {
     tile_height = height;
   }
 
-  // Assumes the size has already been checked.
-  std::unique_ptr<char[]> zero(new char[size]);
-  memset(zero.get(), 0, size);
-  glBindTexture(texture->target(), texture->service_id());
+  {
+    // Add extra scope to destroy zero and the object it owns right
+    // after its usage.
+    // Assumes the size has already been checked.
+    std::unique_ptr<char[]> zero(new char[size]);
+    memset(zero.get(), 0, size);
+    glBindTexture(texture->target(), texture->service_id());
 
-  GLint y = 0;
-  while (y < height) {
-    GLint h = y + tile_height > height ? height - y : tile_height;
-    glTexSubImage2D(
+    GLint y = 0;
+    while (y < height) {
+      GLint h = y + tile_height > height ? height - y : tile_height;
+      glTexSubImage2D(
         target, level, xoffset, yoffset + y, width, h,
         TextureManager::AdjustTexFormat(feature_info_.get(), format),
         type,
         zero.get());
-    y += tile_height;
+      y += tile_height;
+    }
   }
   TextureRef* bound_texture =
       texture_manager()->GetTextureInfoForTarget(&state_, texture->target());
   glBindTexture(texture->target(),
                 bound_texture ? bound_texture->service_id() : 0);
   return true;
 }
 
 bool GLES2DecoderImpl::ClearCompressedTextureLevel(Texture* texture,
                                                    unsigned target,
@@ skipping 12 matching lines @@
   if (!GetCompressedTexSizeInBytes(
           "ClearCompressedTextureLevel", width, height, 1, format,
           &bytes_required)) {
     return false;
   }
 
   TRACE_EVENT1("gpu", "GLES2DecoderImpl::ClearCompressedTextureLevel",
                "bytes_required", bytes_required);
 
   glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-  std::unique_ptr<char[]> zero(new char[bytes_required]);
-  memset(zero.get(), 0, bytes_required);
-  glBindTexture(texture->target(), texture->service_id());
-  glCompressedTexSubImage2D(
+  {
+    // Add extra scope to destroy zero and the object it owns right
+    // after its usage.
+    std::unique_ptr<char[]> zero(new char[bytes_required]);
+    memset(zero.get(), 0, bytes_required);
+    glBindTexture(texture->target(), texture->service_id());
+    glCompressedTexSubImage2D(
       target, level, 0, 0, width, height, format, bytes_required, zero.get());
+  }
   TextureRef* bound_texture =
       texture_manager()->GetTextureInfoForTarget(&state_, texture->target());
   glBindTexture(texture->target(),
                 bound_texture ? bound_texture->service_id() : 0);
   Buffer* bound_buffer = buffer_manager()->GetBufferInfoForTarget(
       &state_, GL_PIXEL_UNPACK_BUFFER);
   if (bound_buffer) {
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bound_buffer->service_id());
   }
   return true;
@@ skipping 1541 matching lines @@
     return;
   }
 
   // Clip to size to source dimensions
   gfx::Rect src(x, y, width, height);
   const gfx::Rect dst(0, 0, size.width(), size.height());
   src.Intersect(dst);
 
   if (src.x() != x || src.y() != y ||
       src.width() != width || src.height() != height) {
-    // some part was clipped so clear the rect.
-    std::unique_ptr<char[]> zero(new char[pixels_size]);
-    memset(zero.get(), 0, pixels_size);
-    glTexImage2D(target, level, TextureManager::AdjustTexInternalFormat(
-                                    feature_info_.get(), internal_format),
-                 width, height, border, format, type, zero.get());
+    {
+      // Add extra scope to destroy zero and the object it owns right
+      // after its usage.
+      // some part was clipped so clear the rect.
+
+      std::unique_ptr<char[]> zero(new char[pixels_size]);
+      memset(zero.get(), 0, pixels_size);
+      glTexImage2D(target, level, TextureManager::AdjustTexInternalFormat(
+        feature_info_.get(), internal_format),
+        width, height, border, format, type, zero.get());

[stanisc, 2016/11/09 22:33:03]

You could consider something like replacing zero.get() with
std::vector<char>(pixel_size). That would allocate and zero the buffer in place
and free it right after returning from glTexImage2D call. 
But the end result would be exactly the same and the existing implementation is
probably more straightforward.

[chengx, 2016/11/10 22:43:46]

Thanks for your suggestion. I will the current version for now.

+    }
+
     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());
@@ skipping 4907 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu