Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/pepper/pepper_compositor_host.cc

 // Copyright 2014 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 "content/renderer/pepper/pepper_compositor_host.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 30 matching lines @@
 namespace {
 
 bool CheckPPFloatRect(const PP_FloatRect& rect, float width, float height) {
     const float kEpsilon = std::numeric_limits<float>::epsilon();
     return (rect.point.x >= -kEpsilon &&
             rect.point.y >= -kEpsilon &&
             rect.point.x + rect.size.width <= width + kEpsilon &&
             rect.point.y + rect.size.height <= height + kEpsilon);
 }
 
-int32_t VerifyCommittedLayer(
-    const ppapi::CompositorLayerData* old_layer,
-    const ppapi::CompositorLayerData* new_layer,
-    scoped_ptr<base::SharedMemory>* image_shm) {
+int32_t VerifyCommittedLayer(const ppapi::CompositorLayerData* old_layer,
+                             const ppapi::CompositorLayerData* new_layer,
+                             std::unique_ptr<base::SharedMemory>* image_shm) {
   if (!new_layer->is_valid())
     return PP_ERROR_BADARGUMENT;
 
   if (new_layer->color) {
     // Make sure the old layer is a color layer too.
     if (old_layer && !old_layer->color)
       return PP_ERROR_BADARGUMENT;
     return PP_OK;
   }
 
@@ skipping 119 matching lines @@
 
   return true;
 }
 
 void PepperCompositorHost::ViewInitiatedPaint() {
   SendCommitLayersReplyIfNecessary();
 }
 
 void PepperCompositorHost::ImageReleased(
     int32_t id,
-    scoped_ptr<base::SharedMemory> shared_memory,
-    scoped_ptr<cc::SharedBitmap> bitmap,
+    std::unique_ptr<base::SharedMemory> shared_memory,
+    std::unique_ptr<cc::SharedBitmap> bitmap,
     const gpu::SyncToken& sync_token,
     bool is_lost) {
   bitmap.reset();
   shared_memory.reset();
   ResourceReleased(id, sync_token, is_lost);
 }
 
 void PepperCompositorHost::ResourceReleased(int32_t id,
                                             const gpu::SyncToken& sync_token,
                                             bool is_lost) {
   host()->SendUnsolicitedReply(
       pp_resource(),
       PpapiPluginMsg_Compositor_ReleaseResource(id, sync_token, is_lost));
 }
 
 void PepperCompositorHost::SendCommitLayersReplyIfNecessary() {
   if (!commit_layers_reply_context_.is_valid())
     return;
   host()->SendReply(commit_layers_reply_context_,
                     PpapiPluginMsg_Compositor_CommitLayersReply());
   commit_layers_reply_context_ = ppapi::host::ReplyMessageContext();
 }
 
 void PepperCompositorHost::UpdateLayer(
     const scoped_refptr<cc::Layer>& layer,
     const ppapi::CompositorLayerData* old_layer,
     const ppapi::CompositorLayerData* new_layer,
-    scoped_ptr<base::SharedMemory> image_shm) {
+    std::unique_ptr<base::SharedMemory> image_shm) {
   // Always update properties on cc::Layer, because cc::Layer
   // will ignore any setting with unchanged value.
   layer->SetIsDrawable(true);
   layer->SetBlendMode(SkXfermode::kSrcOver_Mode);
   layer->SetOpacity(new_layer->common.opacity);
   layer->SetBounds(PP_ToGfxSize(new_layer->common.size));
   layer->SetTransformOrigin(gfx::Point3F(new_layer->common.size.width / 2,
                                          new_layer->common.size.height / 2,
                                          0.0f));
 
@@ skipping 66 matching lines @@
       EnterResourceNoLock<PPB_ImageData_API> enter(new_layer->image->resource,
                                                    true);
       DCHECK(enter.succeeded());
 
       // TODO(penghuang): support all kinds of image.
       PP_ImageDataDesc desc;
       PP_Bool rv = enter.object()->Describe(&desc);
       DCHECK_EQ(rv, PP_TRUE);
       DCHECK_EQ(desc.stride, desc.size.width * 4);
       DCHECK_EQ(desc.format, PP_IMAGEDATAFORMAT_RGBA_PREMUL);
-      scoped_ptr<cc::SharedBitmap> bitmap =
+      std::unique_ptr<cc::SharedBitmap> bitmap =
           ChildThreadImpl::current()
               ->shared_bitmap_manager()
               ->GetBitmapForSharedMemory(image_shm.get());
 
       cc::TextureMailbox mailbox(bitmap.get(), PP_ToGfxSize(desc.size));
       image_layer->SetTextureMailbox(
           mailbox,
           cc::SingleReleaseCallback::Create(base::Bind(
               &PepperCompositorHost::ImageReleased, weak_factory_.GetWeakPtr(),
               new_layer->common.resource_id, base::Passed(&image_shm),
@@ skipping 25 matching lines @@
   return true;
 }
 
 int32_t PepperCompositorHost::OnHostMsgCommitLayers(
     HostMessageContext* context,
     const std::vector<ppapi::CompositorLayerData>& layers,
     bool reset) {
   if (commit_layers_reply_context_.is_valid())
     return PP_ERROR_INPROGRESS;
 
-  scoped_ptr<scoped_ptr<base::SharedMemory>[]> image_shms;
+  std::unique_ptr<std::unique_ptr<base::SharedMemory>[]> image_shms;
   if (layers.size() > 0) {
-    image_shms.reset(new scoped_ptr<base::SharedMemory>[layers.size()]);
+    image_shms.reset(new std::unique_ptr<base::SharedMemory>[layers.size()]);
     if (!image_shms)
       return PP_ERROR_NOMEMORY;
     // Verfiy the layers first, if an error happens, we will return the error to
     // plugin and keep current layers set by the previous CommitLayers()
     // unchanged.
     for (size_t i = 0; i < layers.size(); ++i) {
       const ppapi::CompositorLayerData* old_layer = NULL;
       if (!reset && i < layers_.size())
         old_layer = &layers_[i].pp_layer;
       int32_t rv = VerifyCommittedLayer(old_layer, &layers[i], &image_shms[i]);
@@ skipping 39 matching lines @@
 
   // If the host is not bound to the instance, return PP_OK immediately.
   if (!bound_instance_)
     return PP_OK;
 
   commit_layers_reply_context_ = context->MakeReplyMessageContext();
   return PP_OK_COMPLETIONPENDING;
 }
 
 }  // namespace content