Remove ScopedVector from chrome/browser/ui.

chrome/browser/ui/webui/options/certificate_manager_handler.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/ui/webui/options/certificate_manager_handler.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"  // for FileAccessProvider
 #include "base/i18n/string_compare.h"
 #include "base/id_map.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/ptr_util.h"
 #include "base/posix/safe_strerror.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/certificate_viewer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/certificate_dialogs.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
@@ skipping 1153 matching lines @@
     base::ListValue args;
     args.AppendString(tree_name);
     args.Append(std::move(nodes));
     web_ui()->CallJavascriptFunctionUnsafe("CertificateManager.onPopulateTree",
                                            args);
   }
 }
 
 void CertificateManagerHandler::ShowError(const std::string& title,
                                           const std::string& error) const {
-  ScopedVector<const base::Value> args;
-  args.push_back(new base::StringValue(title));
-  args.push_back(new base::StringValue(error));
-  args.push_back(new base::StringValue(l10n_util::GetStringUTF8(IDS_OK)));
-  args.push_back(base::Value::CreateNullValue().release());  // cancelTitle
-  args.push_back(base::Value::CreateNullValue().release());  // okCallback
-  args.push_back(base::Value::CreateNullValue().release());  // cancelCallback
-  web_ui()->CallJavascriptFunctionUnsafe("AlertOverlay.show", args.get());
+  auto title_value = base::MakeUnique<base::StringValue>(title);
+  auto error_value = base::MakeUnique<base::StringValue>(error);
+  auto ok_title_value =
+      base::MakeUnique<base::StringValue>(l10n_util::GetStringUTF8(IDS_OK));
+  auto cancel_title_value = base::Value::CreateNullValue();
+  auto ok_callback_value = base::Value::CreateNullValue();
+  auto cancel_callback_value = base::Value::CreateNullValue();
+  std::vector<const base::Value*> args = {
+      title_value.get(),       error_value.get(),
+      ok_title_value.get(),    cancel_title_value.get(),
+      ok_callback_value.get(), cancel_callback_value.get()};

[stevenjb, 2017/01/04 17:56:15]

This all seems awkward. Would it make sense to add a version of
CallJavascriptFunctionUnsafe that takes a ListValue*? That would be a lot
simpler:

auto args = base::MakeUnique<base::ListValue>();
args->AppendString(title);
...

Also, this formatting looks odd, did clang do this?

[Avi (use Gerrit), 2017/01/04 18:44:39]

We can't overload just the ListValue, as calling a Javascript function with a
single list parameter is valid. The interface is structured so that the vector
side is implying a list, but a list of arguments...

OTOH, this seems to be designed to encourage the use of ScopedVector.

Let me follow up with a better design if I can find one.
Yep, entirely its doing.

+  web_ui()->CallJavascriptFunctionUnsafe("AlertOverlay.show", args);
 }
 
 void CertificateManagerHandler::ShowImportErrors(
     const std::string& title,
     const net::NSSCertDatabase::ImportCertFailureList& not_imported) const {
   std::string error;
   if (selected_cert_list_.size() == 1)
     error = l10n_util::GetStringUTF8(
         IDS_CERT_MANAGER_IMPORT_SINGLE_NOT_IMPORTED);
   else if (not_imported.size() == selected_cert_list_.size())
@@ skipping 15 matching lines @@
   web_ui()->CallJavascriptFunctionUnsafe("CertificateImportErrorOverlay.show",
                                          title_value, error_value,
                                          cert_error_list);
 }
 
 gfx::NativeWindow CertificateManagerHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 }  // namespace options