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

content/renderer/render_view_impl.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_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
+#include <memory>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/debug/crash_logging.h"
 #include "base/files/file_path.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
 #include "base/process/process.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 683 matching lines @@
     CHECK(params.swapped_out);
     RenderFrameProxy::CreateFrameProxy(
         params.proxy_routing_id, GetRoutingID(), params.opener_frame_route_id,
         MSG_ROUTING_NONE, params.replicated_frame_state);
   }
 
   if (main_render_frame_)
     main_render_frame_->Initialize();
 
 #if defined(OS_ANDROID)
-  content_detectors_.push_back(make_scoped_ptr(new AddressDetector()));
+  content_detectors_.push_back(base::WrapUnique(new AddressDetector()));
   const std::string& contry_iso =
       params.renderer_preferences.network_contry_iso;
   if (!contry_iso.empty()) {
     content_detectors_.push_back(
-        make_scoped_ptr(new PhoneNumberDetector(contry_iso)));
+        base::WrapUnique(new PhoneNumberDetector(contry_iso)));
   }
-  content_detectors_.push_back(make_scoped_ptr(new EmailDetector()));
+  content_detectors_.push_back(base::WrapUnique(new EmailDetector()));
 #endif
 
   RenderThread::Get()->AddRoute(GetRoutingID(), this);
   // Take a reference on behalf of the RenderThread.  This will be balanced
   // when we receive ViewMsg_Close in the RenderWidget (which RenderView
   // inherits from).
   AddRef();
   if (RenderThreadImpl::current()) {
     RenderThreadImpl::current()->WidgetCreated();
     if (is_hidden_)
@@ skipping 742 matching lines @@
   ApplyWebPreferences(prefs, web_view);
 }
 
 void RenderViewImpl::OnForceRedraw(int id) {
   ui::LatencyInfo latency_info;
   if (id) {
     latency_info.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT,
                                   0,
                                   id);
   }
-  scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
+  std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
   if (RenderWidgetCompositor* rwc = compositor()) {
     latency_info_swap_promise_monitor =
         rwc->CreateLatencyInfoSwapPromiseMonitor(&latency_info);
   }
   ScheduleCompositeWithForcedRedraw();
 }
 
 // blink::WebViewClient ------------------------------------------------------
 
 WebView* RenderViewImpl::createView(WebLocalFrame* creator,
@@ skipping 1433 matching lines @@
     // programming error (there are many ways to DoS the user so it's not
     // considered a "real" security check), either in JS requesting many file
     // choosers to pop up, or in a plugin.
     //
     // TODO(brettw) we might possibly want to require a user gesture to open
     // a file picker, which will address this issue in a better way.
     return false;
   }
 
   file_chooser_completions_.push_back(
-      make_scoped_ptr(new PendingFileChooser(params, completion)));
+      base::WrapUnique(new PendingFileChooser(params, completion)));
   if (file_chooser_completions_.size() == 1) {
     // Actually show the browse dialog when this is the first request.
     Send(new ViewHostMsg_RunFileChooser(GetRoutingID(), params));
   }
   return true;
 }
 
 blink::WebSpeechRecognizer* RenderViewImpl::speechRecognizer() {
   if (!speech_recognition_dispatcher_)
     speech_recognition_dispatcher_ = new SpeechRecognitionDispatcher(this);
@@ skipping 181 matching lines @@
   bool handled = false;
   switch (renderer_preferences_.tap_multiple_targets_strategy) {
     case TAP_MULTIPLE_TARGETS_STRATEGY_ZOOM:
       handled = webview()->zoomToMultipleTargetsRect(zoom_rect);
       break;
     case TAP_MULTIPLE_TARGETS_STRATEGY_POPUP: {
       gfx::Size canvas_size =
           gfx::ScaleToCeiledSize(zoom_rect.size(), new_total_scale);
       cc::SharedBitmapManager* manager =
           RenderThreadImpl::current()->shared_bitmap_manager();
-      scoped_ptr<cc::SharedBitmap> shared_bitmap =
+      std::unique_ptr<cc::SharedBitmap> shared_bitmap =
           manager->AllocateSharedBitmap(canvas_size);
       CHECK(!!shared_bitmap);
       {
         SkBitmap bitmap;
         SkImageInfo info = SkImageInfo::MakeN32Premul(canvas_size.width(),
                                                       canvas_size.height());
         bitmap.installPixels(info, shared_bitmap->pixels(), info.minRowBytes());
         SkCanvas canvas(bitmap);
 
         // TODO(trchen): Cleanup the device scale factor mess.
@@ skipping 137 matching lines @@
   if (IsUseZoomForDSFEnabled()) {
     webview()->setZoomFactorForDeviceScaleFactor(device_scale_factor_);
   } else {
     webview()->setDeviceScaleFactor(device_scale_factor_);
   }
   webview()->settings()->setPreferCompositingToLCDTextEnabled(
       PreferCompositingToLCDText(compositor_deps_, device_scale_factor_));
 }
 
 }  // namespace content