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

content/renderer/gpu/gpu_benchmarking_extension.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/gpu/gpu_benchmarking_extension.h"
 
 #include <stddef.h>
+
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/layers/layer.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_drag_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/content_switches.h"
@@ skipping 249 matching lines @@
 
  private:
   WebLocalFrame* web_frame_;
   WebView* web_view_;
   RenderViewImpl* render_view_impl_;
   RenderWidgetCompositor* compositor_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBenchmarkingContext);
 };
 
-void OnMicroBenchmarkCompleted(
-    CallbackAndContext* callback_and_context,
-    scoped_ptr<base::Value> result) {
+void OnMicroBenchmarkCompleted(CallbackAndContext* callback_and_context,
+                               std::unique_ptr<base::Value> result) {
   v8::Isolate* isolate = callback_and_context->isolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Context> context = callback_and_context->GetContext();
   v8::Context::Scope context_scope(context);
   WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
   if (frame) {
-    scoped_ptr<V8ValueConverter> converter =
-        make_scoped_ptr(V8ValueConverter::create());
+    std::unique_ptr<V8ValueConverter> converter =
+        base::WrapUnique(V8ValueConverter::create());
     v8::Local<v8::Value> value = converter->ToV8Value(result.get(), context);
     v8::Local<v8::Value> argv[] = { value };
 
     frame->callFunctionEvenIfScriptDisabled(
         callback_and_context->GetCallback(),
         v8::Object::New(isolate),
         1,
         argv);
   }
 }
@@ skipping 37 matching lines @@
     mouseMove.x = (contentRect.x + contentRect.width / 2) * page_scale_factor;
     mouseMove.y = (contentRect.y + contentRect.height / 2) * page_scale_factor;
     context.web_view()->handleInputEvent(mouseMove);
     context.web_view()->setCursorVisibilityState(true);
   }
 
   scoped_refptr<CallbackAndContext> callback_and_context =
       new CallbackAndContext(
           isolate, callback, context.web_frame()->mainWorldScriptContext());
 
-  scoped_ptr<SyntheticSmoothScrollGestureParams> gesture_params(
+  std::unique_ptr<SyntheticSmoothScrollGestureParams> gesture_params(
       new SyntheticSmoothScrollGestureParams);
 
   if (gesture_source_type < 0 ||
       gesture_source_type > SyntheticGestureParams::GESTURE_SOURCE_TYPE_MAX) {
     return false;
   }
   gesture_params->gesture_source_type =
       static_cast<SyntheticGestureParams::GestureSourceType>(
           gesture_source_type);
 
@@ skipping 49 matching lines @@
                      v8::Local<v8::Function> callback,
                      int gesture_source_type,
                      float speed_in_pixels_s) {
   GpuBenchmarkingContext context;
   if (!context.Init(false))
     return false;
   scoped_refptr<CallbackAndContext> callback_and_context =
       new CallbackAndContext(isolate, callback,
                              context.web_frame()->mainWorldScriptContext());
 
-  scoped_ptr<SyntheticSmoothDragGestureParams> gesture_params(
+  std::unique_ptr<SyntheticSmoothDragGestureParams> gesture_params(
       new SyntheticSmoothDragGestureParams);
 
   // Convert coordinates from CSS pixels to density independent pixels (DIPs).
   float page_scale_factor = context.web_view()->pageScaleFactor();
 
   gesture_params->start_point.SetPoint(start_x * page_scale_factor,
                                        start_y * page_scale_factor);
   gfx::PointF end_point(end_x * page_scale_factor,
                         end_y * page_scale_factor);
   gfx::Vector2dF distance = end_point - gesture_params->start_point;
@@ skipping 260 matching lines @@
       !GetOptionalArg(args, &start_y) ||
       !GetOptionalArg(args, &speed_in_pixels_s)) {
     return false;
   }
 
   scoped_refptr<CallbackAndContext> callback_and_context =
       new CallbackAndContext(args->isolate(),
                              callback,
                              context.web_frame()->mainWorldScriptContext());
 
-  scoped_ptr<SyntheticSmoothScrollGestureParams> gesture_params(
+  std::unique_ptr<SyntheticSmoothScrollGestureParams> gesture_params(
       new SyntheticSmoothScrollGestureParams);
 
   gesture_params->speed_in_pixels_s = speed_in_pixels_s;
 
   gesture_params->anchor.SetPoint(start_x * page_scale_factor,
                                   start_y * page_scale_factor);
 
   distance_length *= page_scale_factor;
   overscroll_length *= page_scale_factor;
   gfx::Vector2dF distance;
@@ skipping 43 matching lines @@
 
 
   if (!GetArg(args, &scale_factor) ||
       !GetArg(args, &anchor_x) ||
       !GetArg(args, &anchor_y) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &relative_pointer_speed_in_pixels_s)) {
     return false;
   }
 
-  scoped_ptr<SyntheticPinchGestureParams> gesture_params(
+  std::unique_ptr<SyntheticPinchGestureParams> gesture_params(
       new SyntheticPinchGestureParams);
 
   // TODO(bokan): Remove page scale here when change land in Catapult.
   // Convert coordinates from CSS pixels to density independent pixels (DIPs).
   float page_scale_factor = context.web_view()->pageScaleFactor();
 
   gesture_params->scale_factor = scale_factor;
   gesture_params->anchor.SetPoint(anchor_x * page_scale_factor,
                                   anchor_y * page_scale_factor);
   gesture_params->relative_pointer_speed_in_pixels_s =
@@ skipping 63 matching lines @@
   int gesture_source_type = SyntheticGestureParams::DEFAULT_INPUT;
 
   if (!GetArg(args, &position_x) ||
       !GetArg(args, &position_y) ||
       !GetOptionalArg(args, &callback) ||
       !GetOptionalArg(args, &duration_ms) ||
       !GetOptionalArg(args, &gesture_source_type)) {
     return false;
   }
 
-  scoped_ptr<SyntheticTapGestureParams> gesture_params(
+  std::unique_ptr<SyntheticTapGestureParams> gesture_params(
       new SyntheticTapGestureParams);
 
   // Convert coordinates from CSS pixels to density independent pixels (DIPs).
   float page_scale_factor = context.web_view()->pageScaleFactor();
 
   gesture_params->position.SetPoint(position_x * page_scale_factor,
                                     position_y * page_scale_factor);
   gesture_params->duration_ms = duration_ms;
 
   if (gesture_source_type < 0 ||
@@ skipping 36 matching lines @@
   if (!GetArg(args, &name) || !GetArg(args, &callback) ||
       !GetOptionalArg(args, &arguments)) {
     return 0;
   }
 
   scoped_refptr<CallbackAndContext> callback_and_context =
       new CallbackAndContext(args->isolate(),
                              callback,
                              context.web_frame()->mainWorldScriptContext());
 
-  scoped_ptr<V8ValueConverter> converter =
-      make_scoped_ptr(V8ValueConverter::create());
+  std::unique_ptr<V8ValueConverter> converter =
+      base::WrapUnique(V8ValueConverter::create());
   v8::Local<v8::Context> v8_context = callback_and_context->GetContext();
-  scoped_ptr<base::Value> value =
-      make_scoped_ptr(converter->FromV8Value(arguments, v8_context));
+  std::unique_ptr<base::Value> value =
+      base::WrapUnique(converter->FromV8Value(arguments, v8_context));
 
   return context.compositor()->ScheduleMicroBenchmark(
       name, std::move(value),
       base::Bind(&OnMicroBenchmarkCompleted,
                  base::RetainedRef(callback_and_context)));
 }
 
 bool GpuBenchmarking::SendMessageToMicroBenchmark(
     int id,
     v8::Local<v8::Object> message) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return false;
 
-  scoped_ptr<V8ValueConverter> converter =
-      make_scoped_ptr(V8ValueConverter::create());
+  std::unique_ptr<V8ValueConverter> converter =
+      base::WrapUnique(V8ValueConverter::create());
   v8::Local<v8::Context> v8_context =
       context.web_frame()->mainWorldScriptContext();
-  scoped_ptr<base::Value> value =
-      make_scoped_ptr(converter->FromV8Value(message, v8_context));
+  std::unique_ptr<base::Value> value =
+      base::WrapUnique(converter->FromV8Value(message, v8_context));
 
   return context.compositor()->SendMessageToMicroBenchmark(id,
                                                            std::move(value));
 }
 
 bool GpuBenchmarking::HasGpuChannel() {
   gpu::GpuChannelHost* gpu_channel =
       RenderThreadImpl::current()->GetGpuChannel();
   return !!gpu_channel;
 }
@@ skipping 15 matching lines @@
           &gpu_driver_bug_workarounds))) {
     return;
   }
 
   v8::Local<v8::Value> result;
   if (gin::TryConvertToV8(args->isolate(), gpu_driver_bug_workarounds, &result))
     args->Return(result);
 }
 
 }  // namespace content