Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/extensions/api/font_settings/font_settings_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.
 
 // Font Settings Extension API implementation.
 
 #include "chrome/browser/extensions/api/font_settings/font_settings_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"

[jdoerrie, 2017/04/06 14:25:50]

#include "base/memory/ptr_util.h"

[vabr (Chromium), 2017/04/07 20:40:40]

Done.

 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/preference/preference_api.h"
 #include "chrome/browser/extensions/api/preference/preference_helpers.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 150 matching lines @@
     events::HistogramValue histogram_value,
     const std::string& event_name,
     const std::string& key,
     const std::string& pref_name) {
   const PrefService::Preference* pref = registrar_.prefs()->FindPreference(
       pref_name);
   CHECK(pref);
 
   base::ListValue args;
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->Set(key, pref->GetValue()->DeepCopy());
+  dict->Set(key, pref->GetValue()->CreateDeepCopy());
   args.Append(std::move(dict));
 
   extensions::preference_helpers::DispatchEventToExtensions(
       profile_, histogram_value, event_name, &args,
       APIPermission::kFontSettings, false, pref_name);
 }
 
 FontSettingsAPI::FontSettingsAPI(content::BrowserContext* context)
     : font_settings_event_router_(
           new FontSettingsEventRouter(Profile::FromBrowserContext(context))) {}
@@ skipping 112 matching lines @@
     }
 
     std::string localized_name;
     if (!font_list_value->GetString(1, &localized_name)) {
       NOTREACHED();
       return false;
     }
 
     std::unique_ptr<base::DictionaryValue> font_name(
         new base::DictionaryValue());
-    font_name->Set(kFontIdKey, new base::Value(name));
-    font_name->Set(kDisplayNameKey, new base::Value(localized_name));
+    font_name->Set(kFontIdKey, base::MakeUnique<base::Value>(name));
+    font_name->Set(kDisplayNameKey,
+                   base::MakeUnique<base::Value>(localized_name));
     result->Append(std::move(font_name));
   }
 
   SetResult(std::move(result));
   return true;
 }
 
 ExtensionFunction::ResponseAction ClearFontPrefExtensionFunction::Run() {
   Profile* profile = Profile::FromBrowserContext(browser_context());
   if (profile->IsOffTheRecord())
@@ skipping 12 matching lines @@
 
   // We don't support incognito-specific font prefs, so don't consider them when
   // getting level of control.
   const bool kIncognito = false;
 
   std::string level_of_control =
       extensions::preference_helpers::GetLevelOfControl(
           profile, extension_id(), GetPrefName(), kIncognito);
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
-  result->Set(GetKey(), pref->GetValue()->DeepCopy());
+  result->Set(GetKey(), pref->GetValue()->CreateDeepCopy());
   result->SetString(kLevelOfControlKey, level_of_control);
   return RespondNow(OneArgument(std::move(result)));
 }
 
 ExtensionFunction::ResponseAction SetFontPrefExtensionFunction::Run() {
   Profile* profile = Profile::FromBrowserContext(browser_context());
   if (profile->IsOffTheRecord())
     return RespondNow(Error(kSetFromIncognitoError));
 
   base::DictionaryValue* details = NULL;
@@ skipping 62 matching lines @@
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions