Replace scoped_ptr with std::unique_ptr in //ui

ui/compositor/layer.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_H_
 #define UI_COMPOSITOR_LAYER_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/base/region.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/surfaces/surface_id.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkRegion.h"
@@ skipping 178 matching lines @@
   // Return the target grayscale if animator is running, or the current
   // grayscale otherwise.
   float GetTargetGrayscale() const;
 
   // Zoom the background by a factor of |zoom|. The effect is blended along the
   // edge across |inset| pixels.
   void SetBackgroundZoom(float zoom, int inset);
 
   // Set the shape of this layer.
   SkRegion* alpha_shape() const { return alpha_shape_.get(); }
-  void SetAlphaShape(scoped_ptr<SkRegion> region);
+  void SetAlphaShape(std::unique_ptr<SkRegion> region);
 
   // Invert the layer.
   bool layer_inverted() const { return layer_inverted_; }
   void SetLayerInverted(bool inverted);
 
   // Return the target opacity if animator is running, or the current opacity
   // otherwise.
   float GetTargetOpacity() const;
 
   // Set a layer mask for a layer.
@@ skipping 40 matching lines @@
 
   // Set to true if this layer always paints completely within its bounds. If so
   // we can omit an unnecessary clear, even if the layer is transparent.
   void SetFillsBoundsCompletely(bool fills_bounds_completely);
 
   const std::string& name() const { return name_; }
   void set_name(const std::string& name) { name_ = name; }
 
   // Set new TextureMailbox for this layer. Note that |mailbox| may hold a
   // shared memory resource or an actual mailbox for a texture.
-  void SetTextureMailbox(const cc::TextureMailbox& mailbox,
-                         scoped_ptr<cc::SingleReleaseCallback> release_callback,
-                         gfx::Size texture_size_in_dip);
+  void SetTextureMailbox(
+      const cc::TextureMailbox& mailbox,
+      std::unique_ptr<cc::SingleReleaseCallback> release_callback,
+      gfx::Size texture_size_in_dip);
   void SetTextureSize(gfx::Size texture_size_in_dip);
   void SetTextureFlipped(bool flipped);
   bool TextureFlipped() const;
 
   // Begins showing content from a surface with a particular id.
   void SetShowSurface(cc::SurfaceId surface_id,
                       const cc::SurfaceLayer::SatisfyCallback& satisfy_callback,
                       const cc::SurfaceLayer::RequireCallback& require_callback,
                       gfx::Size surface_size,
                       float scale,
@@ skipping 39 matching lines @@
   void SuppressPaint();
 
   // Notifies the layer that the device scale factor has changed.
   void OnDeviceScaleFactorChanged(float device_scale_factor);
 
   // Notifies the layer that one of its children has received a new
   // delegated frame.
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip);
 
   // Requets a copy of the layer's output as a texture or bitmap.
-  void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
+  void RequestCopyOfOutput(std::unique_ptr<cc::CopyOutputRequest> request);
 
   // ContentLayerClient
   gfx::Rect PaintableRegion() override;
   scoped_refptr<cc::DisplayItemList> PaintContentsToDisplayList(
       ContentLayerClient::PaintingControlSetting painting_control) override;
   bool FillsBoundsCompletely() const override;
   size_t GetApproximateUnsharedMemoryUsage() const override;
 
   cc::Layer* cc_layer_for_testing() { return cc_layer_; }
 
   // TextureLayerClient
   bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox,
-      scoped_ptr<cc::SingleReleaseCallback>* release_callback,
+      std::unique_ptr<cc::SingleReleaseCallback>* release_callback,
       bool use_shared_memory) override;
 
   float device_scale_factor() const { return device_scale_factor_; }
 
   // Forces a render surface to be used on this layer. This has no positive
   // impact, and is only used for benchmarking/testing purpose.
   void SetForceRenderSurface(bool force);
   bool force_render_surface() const { return force_render_surface_; }
 
   // LayerClient
-  scoped_ptr<base::trace_event::ConvertableToTraceFormat> TakeDebugInfo(
+  std::unique_ptr<base::trace_event::ConvertableToTraceFormat> TakeDebugInfo(
       cc::Layer* layer) override;
 
   // Whether this layer has animations waiting to get sent to its cc::Layer.
   bool HasPendingThreadedAnimationsForTesting() const;
 
   // Triggers a call to SwitchToLayer.
   void SwitchCCLayerForTest();
 
  private:
   friend class LayerOwner;
@@ skipping 88 matching lines @@
   Layer* layer_mask_back_link_;
 
   // The zoom factor to scale the layer by.  Zooming is disabled when this is
   // set to 1.
   float zoom_;
 
   // Width of the border in pixels, where the scaling is blended.
   int zoom_inset_;
 
   // Shape of the window.
-  scoped_ptr<SkRegion> alpha_shape_;
+  std::unique_ptr<SkRegion> alpha_shape_;
 
   std::string name_;
 
   LayerDelegate* delegate_;
 
   LayerOwner* owner_;
 
   scoped_refptr<LayerAnimator> animator_;
 
   // Ownership of the layer is held through one of the strongly typed layer
@@ skipping 11 matching lines @@
   // A cached copy of the nine patch layer's image and aperture.
   // These are required for device scale factor change.
   gfx::ImageSkia nine_patch_layer_image_;
   gfx::Rect nine_patch_layer_aperture_;
 
   // The mailbox used by texture_layer_.
   cc::TextureMailbox mailbox_;
 
   // The callback to release the mailbox. This is only set after
   // SetTextureMailbox is called, before we give it to the TextureLayer.
-  scoped_ptr<cc::SingleReleaseCallback> mailbox_release_callback_;
+  std::unique_ptr<cc::SingleReleaseCallback> mailbox_release_callback_;
 
   // The size of the frame or texture in DIP, set when SetShowDelegatedContent
   // or SetTextureMailbox was called.
   gfx::Size frame_size_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_