Remove ExtensionFunction::SetResult(T*) overload.

chrome/browser/extensions/api/tabs/tabs_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.
 
 #include "chrome/browser/extensions/api/tabs/tabs_api.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 323 matching lines @@
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool WindowsGetAllFunction::RunSync() {
   std::unique_ptr<windows::GetAll::Params> params(
       windows::GetAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::GetAll::Params> extractor(params.get());
-  base::ListValue* window_list = new base::ListValue();
+  std::unique_ptr<base::ListValue> window_list(new base::ListValue());
   const WindowControllerList::ControllerList& windows =
       WindowControllerList::GetInstance()->windows();
   for (WindowControllerList::ControllerList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
     if (!windows_util::CanOperateOnWindow(this, *iter,
                                           extractor.type_filters()))
       continue;
     if (extractor.populate_tabs())
       window_list->Append((*iter)->CreateWindowValueWithTabs(extension()));
     else
       window_list->Append((*iter)->CreateWindowValue());
   }
-  SetResult(window_list);
+  SetResult(std::move(window_list));
   return true;
 }
 
 bool WindowsCreateFunction::ShouldOpenIncognitoWindow(
     const windows::Create::Params::CreateData* create_data,
     std::vector<GURL>* urls, bool* is_error) {
   *is_error = false;
   const IncognitoModePrefs::Availability incognito_availability =
       IncognitoModePrefs::GetAvailability(GetProfile()->GetPrefs());
   bool incognito = false;
@@ skipping 526 matching lines @@
     window_id = *params->query_info.window_id;
 
   int index = -1;
   if (params->query_info.index.get())
     index = *params->query_info.index;
 
   std::string window_type;
   if (params->query_info.window_type != tabs::WINDOW_TYPE_NONE)
     window_type = tabs::ToString(params->query_info.window_type);
 
-  base::ListValue* result = new base::ListValue();
+  std::unique_ptr<base::ListValue> result(new base::ListValue());
   Browser* last_active_browser =
       chrome::FindAnyBrowser(GetProfile(), include_incognito());
   Browser* current_browser = GetCurrentBrowser();
   for (auto* browser : *BrowserList::GetInstance()) {
     if (!GetProfile()->IsSameProfile(browser->profile()))
       continue;
 
     if (!browser->window())
       continue;
 
@@ skipping 89 matching lines @@
       if (loading_status_set && loading != web_contents->IsLoading())
         continue;
 
       result->Append(ExtensionTabUtil::CreateTabObject(web_contents, tab_strip,
                                                        i, extension())
                          ->ToValue()
                          .release());
     }
   }
 
-  SetResult(result);
+  SetResult(std::move(result));
   return true;
 }
 
 bool TabsCreateFunction::RunSync() {
   std::unique_ptr<tabs::Create::Params> params(
       tabs::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ExtensionTabUtil::OpenTabParams options;
   AssignOptionalValue(params->create_properties.window_id, options.window_id);
   AssignOptionalValue(params->create_properties.opener_tab_id,
                       options.opener_tab_id);
   AssignOptionalValue(params->create_properties.selected, options.active);
   // The 'active' property has replaced the 'selected' property.
   AssignOptionalValue(params->create_properties.active, options.active);
   AssignOptionalValue(params->create_properties.pinned, options.pinned);
   AssignOptionalValue(params->create_properties.index, options.index);
   AssignOptionalValue(params->create_properties.url, options.url);
 
   std::string error;
   std::unique_ptr<base::DictionaryValue> result(
       ExtensionTabUtil::OpenTab(this, options, &error));
   if (!result) {
     SetError(error);
     return false;
   }
 
   // Return data about the newly created tab.
   if (has_callback()) {
-    SetResult(result.release());
+    SetResult(std::move(result));
   }
   return true;
 }
 
 bool TabsDuplicateFunction::RunSync() {
   std::unique_ptr<tabs::Duplicate::Params> params(
       tabs::Duplicate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->tab_id;
 
@@ skipping 372 matching lines @@
 
   if (!has_callback())
     return true;
 
   if (num_tabs == 0) {
     error_ = "No tabs given.";
     return false;
   } else if (num_tabs == 1) {
     std::unique_ptr<base::Value> value;
     CHECK(tab_values.get()->Remove(0, &value));
-    SetResult(value.release());
+    SetResult(std::move(value));
   } else {
     // Only return the results as an array if there are multiple tabs.
-    SetResult(tab_values.release());
+    SetResult(std::move(tab_values));
   }
 
   return true;
 }
 
 bool TabsMoveFunction::MoveTab(int tab_id,
                                int* new_index,
                                int iteration,
                                base::ListValue* tab_values,
                                int* window_id) {
@@ skipping 259 matching lines @@
                  this));
 }
 
 void TabsCaptureVisibleTabFunction::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 TabsCaptureVisibleTabFunction::OnCaptureFailure(FailureReason reason) {
   const char* reason_description = "internal error";
   switch (reason) {
     case FAILURE_REASON_UNKNOWN:
       reason_description = "unknown error";
       break;
     case FAILURE_REASON_ENCODING_FAILED:
@@ skipping 95 matching lines @@
   }
 
   registrar_.RemoveAll();
 
   // Call GotLanguage in all cases as we want to guarantee the callback is
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void TabsDetectLanguageFunction::GotLanguage(const std::string& language) {
-  SetResult(new base::StringValue(language.c_str()));
+  SetResult(base::MakeUnique<base::StringValue>(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }
 
 ExecuteCodeInTabFunction::ExecuteCodeInTabFunction()
     : chrome_details_(this), execute_tab_id_(-1) {
 }
 
 ExecuteCodeInTabFunction::~ExecuteCodeInTabFunction() {}
@@ skipping 135 matching lines @@
 
 bool TabsExecuteScriptFunction::ShouldInsertCSS() const {
   return false;
 }
 
 void TabsExecuteScriptFunction::OnExecuteCodeFinished(
     const std::string& error,
     const GURL& on_url,
     const base::ListValue& result) {
   if (error.empty())
-    SetResult(result.DeepCopy());
+    SetResult(result.CreateDeepCopy());
   ExecuteCodeInTabFunction::OnExecuteCodeFinished(error, on_url, result);
 }
 
 bool TabsInsertCSSFunction::ShouldInsertCSS() const {
   return true;
 }
 
 content::WebContents* ZoomAPIFunction::GetWebContents(int tab_id) {
   content::WebContents* web_contents = NULL;
   if (tab_id != -1) {
@@ skipping 135 matching lines @@
   ZoomModeToZoomSettings(zoom_mode, &zoom_settings);
   zoom_settings.default_zoom_factor.reset(new double(
       content::ZoomLevelToZoomFactor(zoom_controller->GetDefaultZoomLevel())));
 
   results_ = api::tabs::GetZoomSettings::Results::Create(zoom_settings);
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions