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

content/renderer/render_widget.cc

 // 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.
 
 #include "content/renderer/render_widget.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
@@ skipping 612 matching lines @@
   SetHidden(false);
   FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
                     WasShown());
 
   if (!needs_repainting)
     return;
 
   // Generate a full repaint.
   if (compositor_) {
     ui::LatencyInfo swap_latency_info(latency_info);
-    scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
+    std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
         compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
     compositor_->SetNeedsForcedRedraw();
   }
   ScheduleComposite();
 }
 
 void RenderWidget::OnRequestMoveAck() {
   DCHECK(pending_window_rect_count_);
   pending_window_rect_count_--;
 }
@@ skipping 36 matching lines @@
     float top_controls_delta) {
   webwidget_->applyViewportDeltas(inner_delta, outer_delta,
                                   elastic_overscroll_delta, page_scale,
                                   top_controls_delta);
 }
 
 void RenderWidget::BeginMainFrame(double frame_time_sec) {
   webwidget_->beginFrame(frame_time_sec);
 }
 
-scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
+std::unique_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(
+    bool fallback) {
   DCHECK(webwidget_);
   // For widgets that are never visible, we don't start the compositor, so we
   // never get a request for a cc::OutputSurface.
   DCHECK(!compositor_never_visible_);
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   bool use_software = fallback;
   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
     use_software = true;
@@ skipping 26 matching lines @@
 #if defined(ENABLE_VULKAN)
   scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider;
 #endif
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   scoped_refptr<ContextProviderCommandBuffer> worker_context_provider;
   if (!use_software) {
 #if defined(ENABLE_VULKAN)
     vulkan_context_provider = cc::VulkanInProcessContextProvider::Create();
     if (vulkan_context_provider) {
       uint32_t output_surface_id = next_output_surface_id_++;
-      return scoped_ptr<cc::OutputSurface>(new DelegatedCompositorOutputSurface(
-          routing_id(), output_surface_id, context_provider,
-          worker_context_provider, vulkan_context_provider,
-          frame_swap_message_queue_));
+      return std::unique_ptr<cc::OutputSurface>(
+          new DelegatedCompositorOutputSurface(
+              routing_id(), output_surface_id, context_provider,
+              worker_context_provider, vulkan_context_provider,
+              frame_swap_message_queue_));
     }
 #endif
 
     context_provider = ContextProviderCommandBuffer::Create(
         CreateGraphicsContext3D(gpu_channel_host.get()),
         RENDER_COMPOSITOR_CONTEXT);
     DCHECK(context_provider);
     worker_context_provider =
         RenderThreadImpl::current()->SharedWorkerContextProvider();
     if (!worker_context_provider) {
       // Cause the compositor to wait and try again.
       return nullptr;
     }
 
 #if defined(OS_ANDROID)
     if (SynchronousCompositorFactory* factory =
             SynchronousCompositorFactory::GetInstance()) {
       uint32_t output_surface_id = next_output_surface_id_++;
       return factory->CreateOutputSurface(
           routing_id(), output_surface_id, frame_swap_message_queue_,
           context_provider, worker_context_provider);
     } else if (RenderThreadImpl::current()->sync_compositor_message_filter()) {
       uint32_t output_surface_id = next_output_surface_id_++;
-      return make_scoped_ptr(new SynchronousCompositorOutputSurface(
+      return base::WrapUnique(new SynchronousCompositorOutputSurface(
           context_provider, worker_context_provider, routing_id(),
           output_surface_id, content::RenderThreadImpl::current()
                                  ->sync_compositor_message_filter(),
           frame_swap_message_queue_));
     }
 #endif
   }
 
   uint32_t output_surface_id = next_output_surface_id_++;
   // Composite-to-mailbox is currently used for layout tests in order to cause
   // them to draw inside in the renderer to do the readback there. This should
   // no longer be the case when crbug.com/311404 is fixed.
   if (!RenderThreadImpl::current() ||
       !RenderThreadImpl::current()->layout_test_mode()) {
     DCHECK(compositor_deps_->GetCompositorImplThreadTaskRunner());
-    return make_scoped_ptr(new DelegatedCompositorOutputSurface(
+    return base::WrapUnique(new DelegatedCompositorOutputSurface(
         routing_id(), output_surface_id, context_provider,
         worker_context_provider,
 #if defined(ENABLE_VULKAN)
         vulkan_context_provider,
 #endif
         frame_swap_message_queue_));
   }
 
   if (!context_provider.get()) {
-    scoped_ptr<cc::SoftwareOutputDevice> software_device(
+    std::unique_ptr<cc::SoftwareOutputDevice> software_device(
         new cc::SoftwareOutputDevice());
 
-    return make_scoped_ptr(new CompositorOutputSurface(
+    return base::WrapUnique(new CompositorOutputSurface(
         routing_id(), output_surface_id, nullptr, nullptr,
 #if defined(ENABLE_VULKAN)
         nullptr,
 #endif
         std::move(software_device), frame_swap_message_queue_, true));
   }
 
-  return make_scoped_ptr(new MailboxOutputSurface(
+  return base::WrapUnique(new MailboxOutputSurface(
       routing_id(), output_surface_id, context_provider,
       worker_context_provider, frame_swap_message_queue_, cc::RGBA_8888));
 }
 
-scoped_ptr<cc::BeginFrameSource>
+std::unique_ptr<cc::BeginFrameSource>
 RenderWidget::CreateExternalBeginFrameSource() {
   return compositor_deps_->CreateExternalBeginFrameSource(routing_id_);
 }
 
 void RenderWidget::DidCommitAndDrawCompositorFrame() {
   // NOTE: Tests may break if this event is renamed or moved. See
   // tab_capture_performancetest.cc.
   TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
   // Notify subclasses that we initiated the paint operation.
   DidInitiatePaint();
@@ skipping 57 matching lines @@
 
   // Notify subclasses that composited rendering was flushed to the screen.
   DidFlushPaint();
 }
 
 void RenderWidget::OnSwapBuffersPosted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
 }
 
 void RenderWidget::RecordFrameTimingEvents(
-    scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
-    scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
+    std::unique_ptr<cc::FrameTimingTracker::CompositeTimingSet>
+        composite_events,
+    std::unique_ptr<cc::FrameTimingTracker::MainFrameTimingSet>
+        main_frame_events) {
   for (const auto& composite_event : *composite_events) {
     int64_t frameId = composite_event.first;
     const std::vector<cc::FrameTimingTracker::CompositeTimingEvent>& events =
         composite_event.second;
     std::vector<blink::WebFrameTimingEvent> webEvents;
     for (size_t i = 0; i < events.size(); ++i) {
       webEvents.push_back(blink::WebFrameTimingEvent(
           events[i].frame_id,
           (events[i].timestamp - base::TimeTicks()).InSecondsF()));
     }
@@ skipping 96 matching lines @@
 
 void RenderWidget::OnDidHandleKeyEvent() {
   if (owner_delegate_)
     owner_delegate_->RenderWidgetDidHandleKeyEvent();
 }
 
 void RenderWidget::OnDidOverscroll(const DidOverscrollParams& params) {
   Send(new InputHostMsg_DidOverscroll(routing_id_, params));
 }
 
-void RenderWidget::OnInputEventAck(scoped_ptr<InputEventAck> input_event_ack) {
+void RenderWidget::OnInputEventAck(
+    std::unique_ptr<InputEventAck> input_event_ack) {
   Send(new InputHostMsg_HandleInputEvent_ACK(routing_id_, *input_event_ack));
 }
 
 void RenderWidget::NotifyInputEventHandled(
     blink::WebInputEvent::Type handled_type) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   InputHandlerManager* input_handler_manager =
       render_thread ? render_thread->input_handler_manager() : NULL;
   if (input_handler_manager) {
     input_handler_manager->NotifyInputEventHandledOnMainThread(routing_id_,
@@ skipping 281 matching lines @@
     // Regardless of whether threaded compositing is enabled, always
     // use this mechanism to force the compositor to redraw. However,
     // the invalidation code path below is still needed for the
     // non-threaded case.
     compositor_->SetNeedsForcedRedraw();
   }
   ScheduleComposite();
 }
 
 // static
-scoped_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
+std::unique_ptr<cc::SwapPromise> RenderWidget::QueueMessageImpl(
     IPC::Message* msg,
     MessageDeliveryPolicy policy,
     FrameSwapMessageQueue* frame_swap_message_queue,
     scoped_refptr<IPC::SyncMessageFilter> sync_message_filter,
     int source_frame_number) {
   bool first_message_for_frame = false;
-  frame_swap_message_queue->QueueMessageForFrame(policy,
-                                                 source_frame_number,
-                                                 make_scoped_ptr(msg),
+  frame_swap_message_queue->QueueMessageForFrame(policy, source_frame_number,
+                                                 base::WrapUnique(msg),
                                                  &first_message_for_frame);
   if (first_message_for_frame) {
-    scoped_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
+    std::unique_ptr<cc::SwapPromise> promise(new QueueMessageSwapPromise(
         sync_message_filter, frame_swap_message_queue, source_frame_number));
     return promise;
   }
   return nullptr;
 }
 
 void RenderWidget::QueueMessage(IPC::Message* msg,
                                 MessageDeliveryPolicy policy) {
   // RenderThreadImpl::current() is NULL in some tests.
   if (!compositor_ || !RenderThreadImpl::current()) {
     Send(msg);
     return;
   }
 
-  scoped_ptr<cc::SwapPromise> swap_promise =
-      QueueMessageImpl(msg,
-                       policy,
-                       frame_swap_message_queue_.get(),
+  std::unique_ptr<cc::SwapPromise> swap_promise =
+      QueueMessageImpl(msg, policy, frame_swap_message_queue_.get(),
                        RenderThreadImpl::current()->sync_message_filter(),
                        compositor_->GetSourceFrameNumber());
 
   if (swap_promise) {
     compositor_->QueueSwapPromise(std::move(swap_promise));
     // Request a commit. This might either A) request a commit ahead of time
     // or B) request a commit which is not needed because there are not
     // pending updates. If B) then the commit will be skipped and the swap
     // promises will be broken (see EarlyOut_NoUpdates). To achieve that we
     // call SetNeedsUpdateLayers instead of SetNeedsCommit so that
@@ skipping 64 matching lines @@
   // Ask the RenderWidgetHost to initiate close.  We could be called from deep
   // in Javascript.  If we ask the RendwerWidgetHost to close now, the window
   // could be closed before the JS finishes executing.  So instead, post a
   // message back to the message loop, which won't run until the JS is
   // complete, and then the Close message can be sent.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&RenderWidget::DoDeferredClose, this));
 }
 
 void RenderWidget::QueueSyntheticGesture(
-    scoped_ptr<SyntheticGestureParams> gesture_params,
+    std::unique_ptr<SyntheticGestureParams> gesture_params,
     const SyntheticGestureCompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   pending_synthetic_gesture_callbacks_.push(callback);
 
   SyntheticGesturePacket gesture_packet;
   gesture_packet.set_gesture_params(std::move(gesture_params));
 
   Send(new InputHostMsg_QueueSyntheticGesture(routing_id_, gesture_packet));
 }
@@ skipping 641 matching lines @@
   Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
 }
 
 void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
 #if defined(OS_ANDROID)
   if (!IsUsingImeThread())
     text_field_is_dirty_ = true;
 #endif
 }
 
-scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
+std::unique_ptr<WebGraphicsContext3DCommandBufferImpl>
 RenderWidget::CreateGraphicsContext3D(gpu::GpuChannelHost* gpu_channel_host) {
   // This is for an offscreen context for raster in the compositor. So the
   // default framebuffer doesn't need alpha, depth, stencil, antialiasing.
   gpu::gles2::ContextCreationAttribHelper attributes;
   attributes.alpha_size = -1;
   attributes.depth_size = 0;
   attributes.stencil_size = 0;
   attributes.samples = 0;
   attributes.sample_buffers = 0;
   attributes.bind_generates_resource = false;
@@ skipping 29 matching lines @@
   limits.mapped_memory_reclaim_limit =
       max_transfer_buffer_usage_mb * kBytesPerMegabyte;
 #endif
   limits.command_buffer_size = 64 * 1024;
   limits.start_transfer_buffer_size = 64 * 1024;
   limits.min_transfer_buffer_size = 64 * 1024;
 
   bool share_resources = true;
   bool automatic_flushes = false;
 
-  return make_scoped_ptr(new WebGraphicsContext3DCommandBufferImpl(
+  return base::WrapUnique(new WebGraphicsContext3DCommandBufferImpl(
       gpu::kNullSurfaceHandle, GetURLForGraphicsContext3D(), gpu_channel_host,
       attributes, gfx::PreferIntegratedGpu, share_resources, automatic_flushes,
       limits, nullptr));
 }
 
 void RenderWidget::RegisterRenderFrameProxy(RenderFrameProxy* proxy) {
   render_frame_proxies_.AddObserver(proxy);
 }
 
 void RenderWidget::UnregisterRenderFrameProxy(RenderFrameProxy* proxy) {
@@ skipping 24 matching lines @@
 }
 
 float RenderWidget::GetOriginalDeviceScaleFactor() const {
   return
       screen_metrics_emulator_ ?
       screen_metrics_emulator_->original_screen_info().deviceScaleFactor :
       device_scale_factor_;
 }
 
 }  // namespace content