Convert //cc from scoped_ptr to std::unique_ptr.

cc/surfaces/surface.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 "cc/surfaces/surface.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 23 matching lines @@
     ReturnedResourceArray current_resources;
     TransferableResource::ReturnResources(
         current_frame_->delegated_frame_data->resource_list,
         &current_resources);
     factory_->UnrefResources(current_resources);
   }
   if (!draw_callback_.is_null())
     draw_callback_.Run(SurfaceDrawStatus::DRAW_SKIPPED);
 }
 
-void Surface::QueueFrame(scoped_ptr<CompositorFrame> frame,
+void Surface::QueueFrame(std::unique_ptr<CompositorFrame> frame,
                          const DrawCallback& callback) {
   DCHECK(factory_);
   ClearCopyRequests();
 
   if (frame) {
     TakeLatencyInfo(&frame->metadata.latency_info);
   }
 
-  scoped_ptr<CompositorFrame> previous_frame = std::move(current_frame_);
+  std::unique_ptr<CompositorFrame> previous_frame = std::move(current_frame_);
   current_frame_ = std::move(frame);
 
   if (current_frame_) {
     factory_->ReceiveFromChild(
         current_frame_->delegated_frame_data->resource_list);
   }
 
   // Empty frames shouldn't be drawn and shouldn't contribute damage, so don't
   // increment frame index for them.
   if (current_frame_ &&
@@ skipping 24 matching lines @@
     current_frame_->metadata.satisfies_sequences.swap(satisfies_sequences);
   if (referenced_surfaces_changed || !satisfies_sequences.empty()) {
     // Notify the manager that sequences were satisfied either if some new
     // sequences were satisfied, or if the set of referenced surfaces changed
     // to force a GC to happen.
     factory_->manager()->DidSatisfySequences(
         SurfaceIdAllocator::NamespaceForId(surface_id_), &satisfies_sequences);
   }
 }
 
-void Surface::RequestCopyOfOutput(scoped_ptr<CopyOutputRequest> copy_request) {
+void Surface::RequestCopyOfOutput(
+    std::unique_ptr<CopyOutputRequest> copy_request) {
   if (current_frame_ &&
       !current_frame_->delegated_frame_data->render_pass_list.empty()) {
-    std::vector<scoped_ptr<CopyOutputRequest>>& copy_requests =
+    std::vector<std::unique_ptr<CopyOutputRequest>>& copy_requests =
         current_frame_->delegated_frame_data->render_pass_list.back()
             ->copy_requests;
 
     if (void* source = copy_request->source()) {
       // Remove existing CopyOutputRequests made on the Surface by the same
       // source.
       auto to_remove =
           std::remove_if(copy_requests.begin(), copy_requests.end(),
-                         [source](const scoped_ptr<CopyOutputRequest>& x) {
+                         [source](const std::unique_ptr<CopyOutputRequest>& x) {
                            return x->source() == source;
                          });
       copy_requests.erase(to_remove, copy_requests.end());
     }
     copy_requests.push_back(std::move(copy_request));
   } else {
     copy_request->SendEmptyResult();
   }
 }
 
 void Surface::TakeCopyOutputRequests(
-    std::multimap<RenderPassId, scoped_ptr<CopyOutputRequest>>* copy_requests) {
+    std::multimap<RenderPassId, std::unique_ptr<CopyOutputRequest>>*
+        copy_requests) {
   DCHECK(copy_requests->empty());
   if (current_frame_) {
     for (const auto& render_pass :
          current_frame_->delegated_frame_data->render_pass_list) {
       for (auto& request : render_pass->copy_requests) {
         copy_requests->insert(
             std::make_pair(render_pass->id, std::move(request)));
       }
       render_pass->copy_requests.clear();
     }
@@ skipping 46 matching lines @@
   if (current_frame_) {
     for (const auto& render_pass :
          current_frame_->delegated_frame_data->render_pass_list) {
       for (const auto& copy_request : render_pass->copy_requests)
         copy_request->SendEmptyResult();
     }
   }
 }
 
 }  // namespace cc