Remove ExtensionFunction::SetResult(T*) overload.

extensions/browser/api/guest_view/web_view/web_view_internal_api.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 "extensions/browser/api/guest_view/web_view/web_view_internal_api.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/stop_find_action.h"
 #include "content/public/common/url_fetcher.h"
@@ skipping 274 matching lines @@
 }
 
 void WebViewInternalCaptureVisibleRegionFunction::OnCaptureSuccess(
     const SkBitmap& bitmap) {
   std::string base64_result;
   if (!EncodeBitmap(bitmap, &base64_result)) {
     OnCaptureFailure(FAILURE_REASON_ENCODING_FAILED);
     return;
   }
 
-  SetResult(new base::StringValue(base64_result));
+  SetResult(base::MakeUnique<base::StringValue>(base64_result));
   SendResponse(true);
 }
 
 void WebViewInternalCaptureVisibleRegionFunction::OnCaptureFailure(
     FailureReason reason) {
   const char* reason_description = "internal error";
   switch (reason) {
     case FAILURE_REASON_UNKNOWN:
       reason_description = "unknown error";
       break;
@@ skipping 133 matching lines @@
 }
 
 WebViewInternalExecuteScriptFunction::WebViewInternalExecuteScriptFunction() {
 }
 
 void WebViewInternalExecuteScriptFunction::OnExecuteCodeFinished(
     const std::string& error,
     const GURL& on_url,
     const base::ListValue& result) {
   if (error.empty())
-    SetResult(result.DeepCopy());
+    SetResult(result.CreateDeepCopy());
   WebViewInternalExecuteCodeFunction::OnExecuteCodeFinished(
       error, on_url, result);
 }
 
 WebViewInternalInsertCSSFunction::WebViewInternalInsertCSSFunction() {
 }
 
 bool WebViewInternalInsertCSSFunction::ShouldInsertCSS() const {
   return true;
 }
@@ skipping 142 matching lines @@
 
 WebViewInternalGetZoomFunction::~WebViewInternalGetZoomFunction() {
 }
 
 bool WebViewInternalGetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
   std::unique_ptr<web_view_internal::GetZoom::Params> params(
       web_view_internal::GetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   double zoom_factor = guest->GetZoom();
-  SetResult(new base::FundamentalValue(zoom_factor));
+  SetResult(base::MakeUnique<base::FundamentalValue>(zoom_factor));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetZoomModeFunction::WebViewInternalSetZoomModeFunction() {
 }
 
 WebViewInternalSetZoomModeFunction::~WebViewInternalSetZoomModeFunction() {
 }
 
@@ skipping 42 matching lines @@
     case ZoomController::ZOOM_MODE_ISOLATED:
       zoom_mode = web_view_internal::ZOOM_MODE_PER_VIEW;
       break;
     case ZoomController::ZOOM_MODE_DISABLED:
       zoom_mode = web_view_internal::ZOOM_MODE_DISABLED;
       break;
     default:
       NOTREACHED();
   }
 
-  SetResult(new base::StringValue(web_view_internal::ToString(zoom_mode)));
+  SetResult(base::MakeUnique<base::StringValue>(
+      web_view_internal::ToString(zoom_mode)));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalFindFunction::WebViewInternalFindFunction() {
 }
 
 WebViewInternalFindFunction::~WebViewInternalFindFunction() {
 }
 
@@ skipping 81 matching lines @@
 
 WebViewInternalGoFunction::~WebViewInternalGoFunction() {
 }
 
 bool WebViewInternalGoFunction::RunAsyncSafe(WebViewGuest* guest) {
   std::unique_ptr<web_view_internal::Go::Params> params(
       web_view_internal::Go::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool successful = guest->Go(params->relative_index);
-  SetResult(new base::FundamentalValue(successful));
+  SetResult(base::MakeUnique<base::FundamentalValue>(successful));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalReloadFunction::WebViewInternalReloadFunction() {
 }
 
 WebViewInternalReloadFunction::~WebViewInternalReloadFunction() {
 }
 
@@ skipping 35 matching lines @@
   WebViewPermissionHelper* web_view_permission_helper =
       WebViewPermissionHelper::FromWebContents(guest->web_contents());
 
   WebViewPermissionHelper::SetPermissionResult result =
       web_view_permission_helper->SetPermission(
           params->request_id, action, user_input);
 
   EXTENSION_FUNCTION_VALIDATE(result !=
                               WebViewPermissionHelper::SET_PERMISSION_INVALID);
 
-  SetResult(new base::FundamentalValue(
+  SetResult(base::MakeUnique<base::FundamentalValue>(
       result == WebViewPermissionHelper::SET_PERMISSION_ALLOWED));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalOverrideUserAgentFunction::
     WebViewInternalOverrideUserAgentFunction() {
 }
 
 WebViewInternalOverrideUserAgentFunction::
@@ skipping 108 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void WebViewInternalClearDataFunction::ClearDataDone() {
   Release();  // Balanced in RunAsync().
   SendResponse(true);
 }
 
 }  // namespace extensions