Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/webui/options/content_settings_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/content_settings_handler.h"
 
 #include <stddef.h>
+
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.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/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/web_site_settings_uma_util.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
@@ skipping 259 matching lines @@
     const std::string& name) {
   for (const auto& chooser_type : kChooserTypeGroupNames) {
     if (chooser_type.name == name)
       return &chooser_type;
   }
   return nullptr;
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the Geolocation exceptions table.
-scoped_ptr<base::DictionaryValue> GetGeolocationExceptionForPage(
+std::unique_ptr<base::DictionaryValue> GetGeolocationExceptionForPage(
     const ContentSettingsPattern& origin,
     const ContentSettingsPattern& embedding_origin,
     ContentSetting setting) {
   base::DictionaryValue* exception = new base::DictionaryValue();
 
   std::string setting_string =
       content_settings::ContentSettingToString(setting);
   DCHECK(!setting_string.empty());
 
   exception->SetString(site_settings::kSetting, setting_string);
   exception->SetString(site_settings::kOrigin, origin.ToString());
   exception->SetString(
       site_settings::kEmbeddingOrigin, embedding_origin.ToString());
-  return make_scoped_ptr(exception);
+  return base::WrapUnique(exception);
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the desktop notifications exceptions table.
-scoped_ptr<base::DictionaryValue> GetNotificationExceptionForPage(
+std::unique_ptr<base::DictionaryValue> GetNotificationExceptionForPage(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSetting setting,
     const std::string& provider_name) {
   std::string embedding_origin;
   if (secondary_pattern != ContentSettingsPattern::Wildcard())
     embedding_origin = secondary_pattern.ToString();
 
   base::DictionaryValue* exception = new base::DictionaryValue();
 
   std::string setting_string =
       content_settings::ContentSettingToString(setting);
   DCHECK(!setting_string.empty());
 
   exception->SetString(site_settings::kSetting, setting_string);
   exception->SetString(site_settings::kOrigin, primary_pattern.ToString());
   exception->SetString(site_settings::kEmbeddingOrigin, embedding_origin);
   exception->SetString(site_settings::kSource, provider_name);
-  return make_scoped_ptr(exception);
+  return base::WrapUnique(exception);
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in a chooser permission exceptions table.
-scoped_ptr<base::DictionaryValue> GetChooserExceptionForPage(
+std::unique_ptr<base::DictionaryValue> GetChooserExceptionForPage(
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     const std::string& provider_name,
     const std::string& name,
     const base::DictionaryValue* object) {
-  scoped_ptr<base::DictionaryValue> exception(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> exception(new base::DictionaryValue());
 
   std::string setting_string =
       content_settings::ContentSettingToString(CONTENT_SETTING_DEFAULT);
   DCHECK(!setting_string.empty());
 
   exception->SetString(site_settings::kSetting, setting_string);
   exception->SetString(site_settings::kOrigin, requesting_origin.spec());
   exception->SetString(
       site_settings::kEmbeddingOrigin, embedding_origin.spec());
   exception->SetString(site_settings::kSource, provider_name);
@@ skipping 791 matching lines @@
   std::sort(zoom_levels.begin(), zoom_levels.end(),
             [](const content::HostZoomMap::ZoomLevelChange& a,
                const content::HostZoomMap::ZoomLevelChange& b) {
               return a.host == b.host ? a.scheme < b.scheme : a.host < b.host;
             });
 
   for (content::HostZoomMap::ZoomLevelVector::const_iterator i =
            zoom_levels.begin();
        i != zoom_levels.end();
        ++i) {
-    scoped_ptr<base::DictionaryValue> exception(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> exception(new base::DictionaryValue);
     switch (i->mode) {
       case content::HostZoomMap::ZOOM_CHANGED_FOR_HOST: {
         exception->SetString(site_settings::kOrigin, i->host);
         std::string host = i->host;
         if (host == content::kUnreachableWebDataURL) {
           host =
               l10n_util::GetStringUTF8(IDS_ZOOMLEVELS_CHROME_ERROR_PAGES_LABEL);
         }
         exception->SetString(site_settings::kOrigin, host);
         break;
@@ skipping 79 matching lines @@
     base::ListValue* exceptions) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (incognito) {
     if (profile->HasOffTheRecordProfile())
       profile = profile->GetOffTheRecordProfile();
     else
       return;
   }
 
   ChooserContextBase* chooser_context = chooser_type.get_context(profile);
-  std::vector<scoped_ptr<ChooserContextBase::Object>> objects =
+  std::vector<std::unique_ptr<ChooserContextBase::Object>> objects =
       chooser_context->GetAllGrantedObjects();
   AllOriginObjects all_origin_objects;
   for (const auto& object : objects) {
     std::string name;
     bool found = object->object.GetString(chooser_type.ui_name_key, &name);
     DCHECK(found);
     // It is safe for this structure to hold references into |objects| because
     // they are both destroyed at the end of this function.
     all_origin_objects[make_pair(object->requesting_origin,
                                  object->source)][object->embedding_origin]
         .insert(make_pair(name, &object->object));
   }
 
   // Keep the exceptions sorted by provider so they will be displayed in
   // precedence order.
-  std::vector<scoped_ptr<base::DictionaryValue>>
+  std::vector<std::unique_ptr<base::DictionaryValue>>
       all_provider_exceptions[HostContentSettingsMap::NUM_PROVIDER_TYPES];
 
   for (const auto& all_origin_objects_entry : all_origin_objects) {
     const GURL& requesting_origin = all_origin_objects_entry.first.first;
     const std::string& source = all_origin_objects_entry.first.second;
     const OneOriginObjects& one_origin_objects =
         all_origin_objects_entry.second;
 
     auto& this_provider_exceptions = all_provider_exceptions
         [HostContentSettingsMap::GetProviderTypeFromSource(source)];
@@ skipping 419 matching lines @@
 
   // Exceptions apply only when the feature is enabled.
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM);
   web_ui()->CallJavascriptFunction(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options