Remove ExtensionFunction::SetResult(T*) overload.

chrome/browser/extensions/api/tab_capture/tab_capture_api.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.
 
 // Implements the Chrome Extensions Tab Capture API.
 
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_api.h"
 
 #include <algorithm>
+#include <memory>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/tab_capture/offscreen_tab.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
@@ skipping 228 matching lines @@
   AddMediaStreamSourceConstraints(target_contents, &params->options);
 
   // At this point, everything is set up in the browser process.  It's now up to
   // the custom JS bindings in the extension's render process to request a
   // MediaStream using navigator.webkitGetUserMedia().  The result dictionary,
   // passed to SetResult() here, contains the extra "hidden options" that will
   // allow the Chrome platform implementation for getUserMedia() to start the
   // virtual audio/video capture devices and set up all the data flows.  The
   // custom JS bindings can be found here:
   // chrome/renderer/resources/extensions/tab_capture_custom_bindings.js
-  base::DictionaryValue* result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->MergeDictionary(params->options.ToValue().get());
-  SetResult(result);
+  SetResult(std::move(result));
   return true;
 }
 
 bool TabCaptureGetCapturedTabsFunction::RunSync() {
   TabCaptureRegistry* registry = TabCaptureRegistry::Get(GetProfile());
-  base::ListValue* const list = new base::ListValue();
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   if (registry)
-    registry->GetCapturedTabs(extension()->id(), list);
-  SetResult(list);
+    registry->GetCapturedTabs(extension()->id(), list.get());
+  SetResult(std::move(list));
   return true;
 }
 
 bool TabCaptureCaptureOffscreenTabFunction::RunSync() {
   std::unique_ptr<TabCapture::CaptureOffscreenTab::Params> params =
       TabCapture::CaptureOffscreenTab::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Make sure the extension is whitelisted for using this API, regardless of
   // Chrome channel.
@@ skipping 44 matching lines @@
     return false;
   }
   FilterDeprecatedGoogConstraints(&params->options);
   AddMediaStreamSourceConstraints(offscreen_tab->web_contents(),
                                   &params->options);
 
   // At this point, everything is set up in the browser process.  It's now up to
   // the custom JS bindings in the extension's render process to complete the
   // request.  See the comment at end of TabCaptureCaptureFunction::RunSync()
   // for more details.
-  base::DictionaryValue* const result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->MergeDictionary(params->options.ToValue().get());
-  SetResult(result);
+  SetResult(std::move(result));
   return true;
 }
 
 // static
 gfx::Size TabCaptureCaptureOffscreenTabFunction::DetermineInitialSize(
     const TabCapture::CaptureOptions& options) {
   static const int kDefaultWidth = 1280;
   static const int kDefaultHeight = 720;
 
   if (!options.video_constraints)
@@ skipping 33 matching lines @@
     }
   }
 
   // No maximum size was provided, so just return the default size bounded by
   // the minimum size.
   return gfx::Size(std::max(kDefaultWidth, min_size.width()),
                    std::max(kDefaultHeight, min_size.height()));
 }
 
 }  // namespace extensions