cc/output/gl_renderer.cc - Issue 1866203004: Convert //cc from scoped_ptr to std::unique_ptr.

Unified Diff: cc/output/gl_renderer.cc

Issue 1866203004: Convert //cc from scoped_ptr to std::unique_ptr. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: scopedptrcc: rebase Created 4 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: cc/output/gl_renderer.cc

diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc

index f618cfd6ae9ed5621ab55f63f7f98d879cc9723b..6487e2e06434b6c9367ab7c9b64e2ae420ece415 100644

--- a/cc/output/gl_renderer.cc

+++ b/cc/output/gl_renderer.cc

@@ -9,13 +9,14 @@

#include <algorithm>

#include <limits>

+#include <memory>

#include <set>

#include <string>

#include <vector>

#include "base/logging.h"

#include "base/macros.h"

-#include "base/memory/scoped_ptr.h"

+#include "base/memory/ptr_util.h"

#include "base/strings/string_split.h"

#include "base/strings/string_util.h"

#include "base/strings/stringprintf.h"

@@ -158,14 +159,14 @@ static GLint GetActiveTextureUnit(GLES2Interface* gl) {

class GLRenderer::ScopedUseGrContext {

public:

- static scoped_ptr<ScopedUseGrContext> Create(GLRenderer* renderer,

- DrawingFrame* frame) {

+ static std::unique_ptr<ScopedUseGrContext> Create(GLRenderer* renderer,

+ DrawingFrame* frame) {

// GrContext for filters is created lazily, and may fail if the context

// is lost.

// TODO(vmiura,bsalomon): crbug.com/487850 Ensure that

// ContextProvider::GrContext() does not return NULL.

if (renderer->output_surface_->context_provider()->GrContext())

- return make_scoped_ptr(new ScopedUseGrContext(renderer, frame));

+ return base::WrapUnique(new ScopedUseGrContext(renderer, frame));

return nullptr;

}

@@ -189,7 +190,7 @@ class GLRenderer::ScopedUseGrContext {

// scoped_gpu_raster_ passes context control to Skia.

}

- scoped_ptr<ScopedGpuRaster> scoped_gpu_raster_;

+ std::unique_ptr<ScopedGpuRaster> scoped_gpu_raster_;

GLRenderer* renderer_;

DrawingFrame* frame_;

@@ -199,7 +200,7 @@ class GLRenderer::ScopedUseGrContext {

struct GLRenderer::PendingAsyncReadPixels {

PendingAsyncReadPixels() : buffer(0) {}

- scoped_ptr<CopyOutputRequest> copy_request;

+ std::unique_ptr<CopyOutputRequest> copy_request;

base::CancelableClosure finished_read_pixels_callback;

unsigned buffer;

@@ -299,19 +300,16 @@ class GLRenderer::SyncQuery {

DISALLOW_COPY_AND_ASSIGN(SyncQuery);

};

-scoped_ptr<GLRenderer> GLRenderer::Create(

+std::unique_ptr<GLRenderer> GLRenderer::Create(

RendererClient* client,

const RendererSettings* settings,

OutputSurface* output_surface,

ResourceProvider* resource_provider,

TextureMailboxDeleter* texture_mailbox_deleter,

int highp_threshold_min) {

- return make_scoped_ptr(new GLRenderer(client,

- settings,

- output_surface,

- resource_provider,

- texture_mailbox_deleter,

- highp_threshold_min));

+ return base::WrapUnique(

+ new GLRenderer(client, settings, output_surface, resource_provider,

+ texture_mailbox_deleter, highp_threshold_min));

}

GLRenderer::GLRenderer(RendererClient* client,

@@ -480,7 +478,7 @@ void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {

}

current_sync_query_ = available_sync_queries_.empty()

- ? make_scoped_ptr(new SyncQuery(gl_))

+ ? base::WrapUnique(new SyncQuery(gl_))

: PopFront(&available_sync_queries_);

read_lock_fence = current_sync_query_->Begin();

@@ -598,7 +596,7 @@ void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,

}

static skia::RefPtr<SkImage> ApplyImageFilter(

- scoped_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,

+ std::unique_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,

ResourceProvider* resource_provider,

const gfx::RectF& src_rect,

const gfx::RectF& dst_rect,

@@ -835,9 +833,9 @@ gfx::Rect GLRenderer::GetBackdropBoundingBoxForRenderPassQuad(

return backdrop_rect;

}

-scoped_ptr<ScopedResource> GLRenderer::GetBackdropTexture(

+std::unique_ptr<ScopedResource> GLRenderer::GetBackdropTexture(

const gfx::Rect& bounding_rect) {

- scoped_ptr<ScopedResource> device_background_texture =

+ std::unique_ptr<ScopedResource> device_background_texture =

ScopedResource::Create(resource_provider_);

// CopyTexImage2D fails when called on a texture having immutable storage.

device_background_texture->Allocate(

@@ -927,7 +925,7 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,

ShouldApplyBackgroundFilters(quad) ||

settings_->force_blending_with_shaders;

- scoped_ptr<ScopedResource> background_texture;

+ std::unique_ptr<ScopedResource> background_texture;

skia::RefPtr<SkImage> background_image;

GLuint background_image_id = 0;

gfx::Rect background_rect;

@@ -1041,7 +1039,7 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,

}

- scoped_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;

+ std::unique_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;

unsigned mask_texture_id = 0;

SamplerType mask_sampler = SAMPLER_TYPE_NA;

if (quad->mask_resource_id()) {

@@ -1051,13 +1049,13 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,

mask_sampler = SamplerTypeFromTextureTarget(mask_resource_lock->target());

}

- scoped_ptr<ResourceProvider::ScopedSamplerGL> contents_resource_lock;

+ std::unique_ptr<ResourceProvider::ScopedSamplerGL> contents_resource_lock;

if (filter_image_id) {

DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));

gl_->BindTexture(GL_TEXTURE_2D, filter_image_id);

} else {

contents_resource_lock =

- make_scoped_ptr(new ResourceProvider::ScopedSamplerGL(

+ base::WrapUnique(new ResourceProvider::ScopedSamplerGL(

resource_provider_, contents_texture->id(), GL_LINEAR));

DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),

contents_resource_lock->target());

@@ -1220,7 +1218,8 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,

gl_->Uniform4fv(locations.color_offset, 1, offset);

}

- scoped_ptr<ResourceProvider::ScopedSamplerGL> shader_background_sampler_lock;

+ std::unique_ptr<ResourceProvider::ScopedSamplerGL>

+ shader_background_sampler_lock;

if (locations.backdrop != -1) {

DCHECK(background_texture || background_image_id);

DCHECK_NE(locations.backdrop, 0);

@@ -1240,11 +1239,10 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,

gl_->Uniform1i(locations.original_backdrop, ++last_texture_unit);

}

if (background_texture) {

- shader_background_sampler_lock = make_scoped_ptr(

- new ResourceProvider::ScopedSamplerGL(resource_provider_,

- background_texture->id(),

- GL_TEXTURE0 + last_texture_unit,

- GL_LINEAR));

+ shader_background_sampler_lock =

+ base::WrapUnique(new ResourceProvider::ScopedSamplerGL(

+ resource_provider_, background_texture->id(),

+ GL_TEXTURE0 + last_texture_unit, GL_LINEAR));

DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),

shader_background_sampler_lock->target());

}

@@ -1968,7 +1966,7 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,

ResourceProvider::ScopedSamplerGL v_plane_lock(

resource_provider_, quad->v_plane_resource_id(), GL_TEXTURE3, GL_LINEAR);

DCHECK_EQ(y_plane_lock.target(), v_plane_lock.target());

- scoped_ptr<ResourceProvider::ScopedSamplerGL> a_plane_lock;

+ std::unique_ptr<ResourceProvider::ScopedSamplerGL> a_plane_lock;

if (use_alpha_plane) {

a_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(

resource_provider_, quad->a_plane_resource_id(), GL_TEXTURE4,

@@ -2542,7 +2540,7 @@ void GLRenderer::EnsureScissorTestDisabled() {

void GLRenderer::CopyCurrentRenderPassToBitmap(

DrawingFrame* frame,

- scoped_ptr<CopyOutputRequest> request) {

+ std::unique_ptr<CopyOutputRequest> request) {

TRACE_EVENT0("cc", "GLRenderer::CopyCurrentRenderPassToBitmap");

gfx::Rect copy_rect = frame->current_render_pass->output_rect;

if (request->has_area())

@@ -2656,7 +2654,7 @@ void GLRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {

CompositorFrame compositor_frame;

compositor_frame.metadata = metadata;

- compositor_frame.gl_frame_data = make_scoped_ptr(new GLFrameData);

+ compositor_frame.gl_frame_data = base::WrapUnique(new GLFrameData);

compositor_frame.gl_frame_data->size = surface_size;

if (capabilities_.using_partial_swap) {

// If supported, we can save significant bandwidth by only swapping the

@@ -2732,7 +2730,7 @@ void GLRenderer::EnsureBackbuffer() {

void GLRenderer::GetFramebufferPixelsAsync(

const DrawingFrame* frame,

const gfx::Rect& rect,

- scoped_ptr<CopyOutputRequest> request) {

+ std::unique_ptr<CopyOutputRequest> request) {

DCHECK(!request->IsEmpty());

if (request->IsEmpty())

return;

@@ -2783,7 +2781,7 @@ void GLRenderer::GetFramebufferPixelsAsync(

TextureMailbox texture_mailbox(mailbox, sync_token, GL_TEXTURE_2D);

- scoped_ptr<SingleReleaseCallback> release_callback;

+ std::unique_ptr<SingleReleaseCallback> release_callback;

if (own_mailbox) {

gl_->BindTexture(GL_TEXTURE_2D, 0);

release_callback = texture_mailbox_deleter_->GetReleaseCallback(

@@ -2799,7 +2797,8 @@ void GLRenderer::GetFramebufferPixelsAsync(

DCHECK(request->force_bitmap_result());

- scoped_ptr<PendingAsyncReadPixels> pending_read(new PendingAsyncReadPixels);

+ std::unique_ptr<PendingAsyncReadPixels> pending_read(

+ new PendingAsyncReadPixels);

pending_read->copy_request = std::move(request);

pending_async_read_pixels_.insert(pending_async_read_pixels_.begin(),

std::move(pending_read));

@@ -2863,7 +2862,7 @@ void GLRenderer::FinishedReadback(unsigned source_buffer,

PendingAsyncReadPixels* current_read = iter->get();

uint8_t* src_pixels = NULL;

- scoped_ptr<SkBitmap> bitmap;

+ std::unique_ptr<SkBitmap> bitmap;

if (source_buffer != 0) {

gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, source_buffer);

@@ -2873,7 +2872,7 @@ void GLRenderer::FinishedReadback(unsigned source_buffer,

if (src_pixels) {

bitmap.reset(new SkBitmap);

bitmap->allocN32Pixels(size.width(), size.height());

- scoped_ptr<SkAutoLockPixels> lock(new SkAutoLockPixels(*bitmap));

+ std::unique_ptr<SkAutoLockPixels> lock(new SkAutoLockPixels(*bitmap));

uint8_t* dest_pixels = static_cast<uint8_t*>(bitmap->getPixels());

size_t row_bytes = size.width() * 4;

@@ -2950,7 +2949,7 @@ bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,

SetStencilEnabled(false);

gl_->BindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_);

current_framebuffer_lock_ =

- make_scoped_ptr(new ResourceProvider::ScopedWriteLockGL(

+ base::WrapUnique(new ResourceProvider::ScopedWriteLockGL(

resource_provider_, texture->id()));

unsigned texture_id = current_framebuffer_lock_->texture_id();

gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,

@@ -2992,8 +2991,8 @@ void GLRenderer::InitializeSharedObjects() {

gl_->GenFramebuffers(1, &offscreen_framebuffer_id_);

shared_geometry_ =

- make_scoped_ptr(new StaticGeometryBinding(gl_, QuadVertexRect()));

- clipped_geometry_ = make_scoped_ptr(new DynamicGeometryBinding(gl_));

+ base::WrapUnique(new StaticGeometryBinding(gl_, QuadVertexRect()));

+ clipped_geometry_ = base::WrapUnique(new DynamicGeometryBinding(gl_));

}

void GLRenderer::PrepareGeometry(BoundGeometry binding) {

@@ -3547,7 +3546,7 @@ void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {

unsigned texture_id = 0;

if (ca_layer_overlay.contents_resource_id) {

pending_overlay_resources_.push_back(

- make_scoped_ptr(new ResourceProvider::ScopedReadLockGL(

+ base::WrapUnique(new ResourceProvider::ScopedReadLockGL(

resource_provider_, ca_layer_overlay.contents_resource_id)));

texture_id = pending_overlay_resources_.back()->texture_id();

}

@@ -3588,7 +3587,7 @@ void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {

DCHECK(texture_id || IsContextLost());

} else {

pending_overlay_resources_.push_back(

- make_scoped_ptr(new ResourceProvider::ScopedReadLockGL(

+ base::WrapUnique(new ResourceProvider::ScopedReadLockGL(

resource_provider_, overlay.resource_id)));

texture_id = pending_overlay_resources_.back()->texture_id();

}

« no previous file with comments | « cc/output/gl_renderer.h ('k') | cc/output/gl_renderer_unittest.cc » ('j') | no next file with comments »