Re-write many calls to WrapUnique() with MakeUnique()

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 511 matching lines @@
     }
 
     while (!pending_sync_queries_.empty()) {
       if (pending_sync_queries_.front()->IsPending())
         break;
 
       available_sync_queries_.push_back(PopFront(&pending_sync_queries_));
     }
 
     current_sync_query_ = available_sync_queries_.empty()
-                              ? base::WrapUnique(new SyncQuery(gl_))
+                              ? base::MakeUnique<SyncQuery>(gl_)
                               : PopFront(&available_sync_queries_);
 
     read_lock_fence = current_sync_query_->Begin();
   } else {
     read_lock_fence =
         make_scoped_refptr(new ResourceProvider::SynchronousFence(gl_));
   }
   resource_provider_->SetReadLockFence(read_lock_fence.get());
 
   // Insert WaitSyncTokenCHROMIUM on quad resources prior to drawing the frame,
@@ skipping 709 matching lines @@
     DCHECK(filter_image_id);
     DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
     gl_->BindTexture(GL_TEXTURE_2D, filter_image_id);
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
     params->source_needs_flip = params->filter_image->getTexture()->origin() ==
                                 kBottomLeft_GrSurfaceOrigin;
   } else {
     params->contents_resource_lock =
-        base::WrapUnique(new ResourceProvider::ScopedSamplerGL(
-            resource_provider_, params->contents_texture->id(), GL_LINEAR));
+        base::MakeUnique<ResourceProvider::ScopedSamplerGL>(
+            resource_provider_, params->contents_texture->id(), GL_LINEAR);
     DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               params->contents_resource_lock->target());
     params->source_needs_flip = params->flip_texture;
   }
 }
 
 void GLRenderer::UpdateRPDQBlendMode(DrawRenderPassDrawQuadParams* params) {
   SkXfermode::Mode blend_mode = params->quad->shared_quad_state->blend_mode;
   SetBlendEnabled(!params->use_shaders_for_blending &&
                   (params->quad->ShouldDrawWithBlending() ||
@@ skipping 196 matching lines @@
 
     if (params->background_image_id) {
       gl_->ActiveTexture(GL_TEXTURE0 + last_texture_unit);
       gl_->BindTexture(GL_TEXTURE_2D, params->background_image_id);
       gl_->ActiveTexture(GL_TEXTURE0);
       if (params->mask_for_background)
         gl_->Uniform1i(locations.original_backdrop, ++last_texture_unit);
     }
     if (params->background_texture) {
       params->shader_background_sampler_lock =
-          base::WrapUnique(new ResourceProvider::ScopedSamplerGL(
+          base::MakeUnique<ResourceProvider::ScopedSamplerGL>(
               resource_provider_, params->background_texture->id(),
-              GL_TEXTURE0 + last_texture_unit, GL_LINEAR));
+              GL_TEXTURE0 + last_texture_unit, GL_LINEAR);
       DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
                 params->shader_background_sampler_lock->target());
     }
   }
 
   SetShaderOpacity(params->quad->shared_quad_state->opacity, locations.alpha);
   SetShaderQuadF(params->surface_quad, locations.quad);
 }
 
 void GLRenderer::DrawRPDQ(const DrawRenderPassDrawQuadParams& params) {
@@ skipping 1695 matching lines @@
                                           const ScopedResource* texture) {
   DCHECK(texture->id());
 
   // Explicitly release lock, otherwise we can crash when try to lock
   // same texture again.
   current_framebuffer_lock_ = nullptr;
 
   SetStencilEnabled(false);
   gl_->BindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_);
   current_framebuffer_lock_ =
-      base::WrapUnique(new ResourceProvider::ScopedWriteLockGL(
-          resource_provider_, texture->id(), false));
+      base::MakeUnique<ResourceProvider::ScopedWriteLockGL>(
+          resource_provider_, texture->id(), false);
   current_framebuffer_format_ = texture->format();
   unsigned texture_id = current_framebuffer_lock_->texture_id();
   gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                             texture_id, 0);
 
   DCHECK(gl_->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
              GL_FRAMEBUFFER_COMPLETE ||
          IsContextLost());
   return true;
 }
@@ skipping 21 matching lines @@
                 current_window_space_viewport_.height());
 }
 
 void GLRenderer::InitializeSharedObjects() {
   TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
 
   // Create an FBO for doing offscreen rendering.
   gl_->GenFramebuffers(1, &offscreen_framebuffer_id_);
 
   shared_geometry_ =
-      base::WrapUnique(new StaticGeometryBinding(gl_, QuadVertexRect()));
-  clipped_geometry_ = base::WrapUnique(new DynamicGeometryBinding(gl_));
+      base::MakeUnique<StaticGeometryBinding>(gl_, QuadVertexRect());
+  clipped_geometry_ = base::MakeUnique<DynamicGeometryBinding>(gl_);
 }
 
 void GLRenderer::PrepareGeometry(BoundGeometry binding) {
   if (binding == bound_geometry_) {
     return;
   }
 
   switch (binding) {
     case SHARED_BINDING:
       shared_geometry_->PrepareForDraw();
@@ skipping 517 matching lines @@
       ScheduleRenderPassDrawQuad(&ca_layer_overlay, frame);
       shared_state = nullptr;
       ++copied_render_pass_count;
       continue;
     }
 
     ResourceId contents_resource_id = ca_layer_overlay.contents_resource_id;
     unsigned texture_id = 0;
     if (contents_resource_id) {
       pending_overlay_resources_.push_back(
-          base::WrapUnique(new ResourceProvider::ScopedReadLockGL(
-              resource_provider_, contents_resource_id)));
+          base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
+              resource_provider_, contents_resource_id));
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
     GLfloat contents_rect[4] = {
         ca_layer_overlay.contents_rect.x(), ca_layer_overlay.contents_rect.y(),
         ca_layer_overlay.contents_rect.width(),
         ca_layer_overlay.contents_rect.height(),
     };
     GLfloat bounds_rect[4] = {
         ca_layer_overlay.bounds_rect.x(), ca_layer_overlay.bounds_rect.y(),
         ca_layer_overlay.bounds_rect.width(),
@@ skipping 34 matching lines @@
     return;
 
   OverlayCandidateList& overlays = frame->overlay_list;
   for (const OverlayCandidate& overlay : overlays) {
     unsigned texture_id = 0;
     if (overlay.use_output_surface_for_resource) {
       texture_id = output_surface_->GetOverlayTextureId();
       DCHECK(texture_id || IsContextLost());
     } else {
       pending_overlay_resources_.push_back(
-          base::WrapUnique(new ResourceProvider::ScopedReadLockGL(
-              resource_provider_, overlay.resource_id)));
+          base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
+              resource_provider_, overlay.resource_id));
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 // This function draws the RenderPassDrawQuad into a temporary
@@ skipping 150 matching lines @@
   }
 
   Resource* resource = nullptr;
   gfx::RectF new_bounds;
   CopyRenderPassDrawQuadToOverlayResource(ca_layer_overlay, &resource,
                                           external_frame, &new_bounds);
   if (!resource || !resource->id())
     return;
 
   pending_overlay_resources_.push_back(
-      base::WrapUnique(new ResourceProvider::ScopedReadLockGL(
-          resource_provider_, resource->id())));
+      base::MakeUnique<ResourceProvider::ScopedReadLockGL>(resource_provider_,
+                                                           resource->id()));
   unsigned texture_id = pending_overlay_resources_.back()->texture_id();
 
   // Once a resource is released, it is marked as "busy". It will be
   // available for reuse after the ScopedReadLockGL is destroyed.
   overlay_resource_pool_->ReleaseResource(resource);
 
   GLfloat contents_rect[4] = {
       ca_layer_overlay->contents_rect.x(), ca_layer_overlay->contents_rect.y(),
       ca_layer_overlay->contents_rect.width(),
       ca_layer_overlay->contents_rect.height(),
@@ skipping 14 matching lines @@
 
   gl_->ScheduleCALayerSharedStateCHROMIUM(
       ca_layer_overlay->shared_state->opacity, is_clipped, clip_rect,
       sorting_context_id, gl_transform);
   gl_->ScheduleCALayerCHROMIUM(
       texture_id, contents_rect, ca_layer_overlay->background_color,
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 }  // namespace cc