Convert //components/mus from scoped_ptr to std::unique_ptr

components/mus/ws/platform_display.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 "components/mus/ws/platform_display.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 264 matching lines @@
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
   if (ime)
     ime->SetImeVisibility(visible);
 }
 
 void DefaultPlatformDisplay::Draw() {
   if (!delegate_->GetRootWindow()->visible())
     return;
 
   // TODO(fsamuel): We should add a trace for generating a top level frame.
-  scoped_ptr<cc::CompositorFrame> frame(GenerateCompositorFrame());
+  std::unique_ptr<cc::CompositorFrame> frame(GenerateCompositorFrame());
   frame_pending_ = true;
   if (top_level_display_client_) {
     top_level_display_client_->SubmitCompositorFrame(
         std::move(frame), base::Bind(&DefaultPlatformDisplay::DidDraw,
                                      weak_factory_.GetWeakPtr()));
   }
   dirty_rect_ = gfx::Rect();
 }
 
 void DefaultPlatformDisplay::DidDraw() {
@@ skipping 26 matching lines @@
   mojom::ViewportMetrics old_metrics;
   old_metrics.size_in_pixels = metrics_.size_in_pixels.Clone();
   old_metrics.device_pixel_ratio = metrics_.device_pixel_ratio;
 
   metrics_.size_in_pixels = mojo::Size::From(size);
   metrics_.device_pixel_ratio = device_pixel_ratio;
 
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
-scoped_ptr<cc::CompositorFrame>
+std::unique_ptr<cc::CompositorFrame>
 DefaultPlatformDisplay::GenerateCompositorFrame() {
-  scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+  std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
   render_pass->damage_rect = dirty_rect_;
   render_pass->output_rect = gfx::Rect(metrics_.size_in_pixels.To<gfx::Size>());
 
   std::set<WindowId> referenced_window_ids;
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
                  1.0f, &referenced_window_ids);
 
-  scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
+  std::unique_ptr<cc::DelegatedFrameData> frame_data(
+      new cc::DelegatedFrameData);
   frame_data->device_scale_factor = metrics_.device_pixel_ratio;
   frame_data->render_pass_list.push_back(std::move(render_pass));
 
-  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   frame->delegated_frame_data = std::move(frame_data);
   return frame;
 }
 
 void DefaultPlatformDisplay::OnBoundsChanged(const gfx::Rect& new_bounds) {
   UpdateMetrics(new_bounds.size(), metrics_.device_pixel_ratio);
 }
 
 void DefaultPlatformDisplay::OnDamageRect(const gfx::Rect& damaged_region) {
   dirty_rect_.Union(damaged_region);
@@ skipping 66 matching lines @@
   UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void DefaultPlatformDisplay::OnActivationChanged(bool active) {}
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
-    scoped_ptr<cc::CopyOutputRequest> output_request) {
+    std::unique_ptr<cc::CopyOutputRequest> output_request) {
   if (top_level_display_client_)
     top_level_display_client_->RequestCopyOfOutput(std::move(output_request));
 }
 
 }  // namespace ws
 
 }  // namespace mus